AI Coding Agent for SDLC is a course in placing AI agents in every phase of software development, from planning and task breakdown with AGENTS.md to frontend and backend work, MCP, skills, subagents, hooks, code review, quality gates, Playwright testing and deployment. It suits developers already using AI, tech leads setting team standards and DevOps engineers.
Most developers already use AI to help write code, but they use it one task at a time and paste the output back in, which captures value only during the coding step. The reality is that a development team spends more time on planning, breaking down work, reviewing code, testing, chasing problems, deploying and operating the system than on typing code. This course organizes its content around the phases of the software development lifecycle and places an AI agent into every phase deliberately. Learners first understand how an agent actually works: the agentic loop, the context window, permissions and cost control. They then apply it for real,
from planning and breaking requirements into tasks an agent can pick up, preparing context with files such as AGENTS.md and a design system so output matches team standards, developing frontend and backend iteratively while handling errors and logs, extending capability with MCP, skills, subagents, hooks and plugins, having the agent write tests, review code, check security and enforce a quality gate before merge, running end-to-end tests with Playwright, and finally using the agent for deployment, routine work and automatic documentation. It closes with a capstone that walks every phase on one real feature. (3 days, 6 hours per day, 18 hours in total, Intermediate level.)
Course Details
A 3-day course, 6 hours per day (18 hours in total, 09:00-16:00), delivered as lectures with labs that build on one continuous project across all three days. Intermediate level. Learners must be able to program and bring their own AI coding agent account. The course focuses on the thinking and the workflow across SDLC phases rather than a deep dive into any single tool, so it transfers to other agents as the technology changes. Anyone wanting a Claude Code specific deep dive should take the separate Claude Code Roadmap 12 Units course. Learners take home a lab guide, context templates (AGENTS.md, DESIGN.md) and sample source code from every lab.
Section 1: How an AI Coding Agent Works
Asking an AI one question at a time versus delegating work to an agent that iterates
The agentic loop: analyze, act, verify and correct until the task is done
The context window and how an overlong context degrades output quality
The agent harness and permission model that define what the agent may touch
Estimating and controlling token cost before it runs away
Section 2: Choosing and Configuring Tooling for the Team
The categories of AI coding agent in real use and the differences that matter
Criteria for choosing tooling that fits your technology stack and budget
Setting permissions so the agent works freely but the codebase stays safe
Confidentiality considerations when organizational code meets external tools
Lab: install and configure an agent against your own project
Section 3: Planning with AI
Using AI to research options and weigh trade-offs before deciding
Having AI ask questions back to close requirement gaps before work starts
Breaking requirements into tasks and issues scoped tightly enough for an agent
Sequencing work and judging which tasks belong to the agent and which to a person
Lab: break one feature into a task list ready to hand to an agent
Section 4: Preparing Context with AGENTS.md and Conventions
The role of the context file the agent reads before every piece of work
Writing AGENTS.md with coding conventions, project structure and everyday commands
Keeping context tight so the important information is not buried
Using memory to carry what must persist between sessions
Sharing one context set across the whole team through Git
Lab: write the context file for your project and compare output before and after
Section 5: Design System and API Design as Context
Making the agent follow the existing design system instead of inventing a new style
Writing DESIGN.md to describe the look, behaviour and existing components
Fixing the API spec first so frontend and backend can proceed in parallel
Using the spec as the contract the agent must satisfy and you can verify against
Lab: write DESIGN.md and the API spec for the feature you planned earlier
Section 6: Frontend Development with an Agent
Delegating interface work in small rounds rather than asking for a whole page at once
Making the agent reuse the components and design system you already have
Reviewing each round and directing precise fixes without rewriting whole files
Managing state and wiring to the API according to the agreed spec
Lab: build the interface of a real feature with an agent until it works
Section 7: Backend Development with an Agent
Having the agent build endpoints against the API spec you wrote
Designing the data layer and managing schema changes so they stay traceable
Handling validation, access control and error handling
Reviewing what the agent wrote before merging it into the main code
Lab: build the server-side API and connect it to the interface you made
Section 8: Handling Errors, Logs and Shifting Context
Giving the agent enough context and log detail to actually find the cause
Recognizing when the agent is looping without progress and how to break the cycle
Resetting or condensing context when length starts degrading quality
Using Git as the safety net so you can always roll back
Lab: work through a real problem in your project alongside the agent
Section 9: Connecting External Tools with MCP
What the Model Context Protocol adds once the agent can reach external tools
Configuring an MCP server and connecting it to an organizational database or API
Restricting each connection on least-privilege principles
Verifying the agent calls the right tool and gets usable results
Lab: connect the agent to your project database through MCP
Section 10: Skills, Subagents, Hooks and Plugins
Building skills so repeatedly explained work becomes instantly callable
Using subagents to split large work and merge the results
Using hooks to insert automatic checks at the moments that matter
Using plugins and distributing one configuration set across the team
Lab: build a skill and set a hook for your own team standard
Section 11: Agent-Written Tests and Quality Gates
Deciding what level of test the agent should write and how far coverage should go
Checking that agent-written tests exercise real behaviour rather than just passing
Defining the quality gate that must pass before merging to the main branch
Setting the pipeline to stop itself when quality falls below the bar
Lab: have the agent write tests for your feature and set up the quality gate
Section 12: Code Review and Security Checks with AI
Using AI to review code and flag quality and performance risks
Basic security checks such as user input handling and secret management
The limits of AI review and where a person must decide
Writing review comments the code owner can act on
Lab: review a classmate pull request with AI and summarize what you found
Section 13: End-to-End and QA with Playwright
Choosing the user journeys worth covering end to end
Having the agent generate Playwright scripts from test scenarios
Choosing selectors and handling waits so results stay stable
Visual regression and producing a testing report the team can read
Lab: build an end-to-end suite for the main journey and get it passing
Section 14: Deployment, Operations and Automatic Documentation
Using the agent to prepare and verify the steps before a deployment
Managing environment variables and secrets safely
Using agents for routine and scheduled work once the system is live
Generating and updating project documentation so it keeps pace with the code
Lab: deploy the feature built over three days along with its documentation
Section 15: Capstone and Team Adoption
Capstone: walk every SDLC phase on one feature from planning through delivery
Presenting your workflow and why the agent did or did not handle each phase
Judging which tooling suits your own team workflow
How to start with a real team and how to measure whether it pays off
Workshop: present your work and review the workflow with the instructor
A chat assistant gives you text that you still have to apply yourself. An agent takes a goal and works in what is called an agentic loop: it analyses the task, edits files or runs commands, checks the result and repeats until the work is done. It can only do what its harness and permission settings allow, so define the scope of the task and its permissions clearly before handing it over.
AGENTS.md is a plain text file in the project that the agent reads as context before it starts work, rather like a README written for the agent. It should describe the project structure, the build and test commands, the team's coding conventions and key restrictions, such as files that must not be changed. Keep it concise, because every line takes up room in the context window, and update it whenever team conventions change.
Start by breaking the requirement into small tasks with clear completion criteria, and prepare the context the agent needs, such as the design system and API design. Then have the agent work one task at a time, reviewing the diff and running tests after each round before moving on, and put quality gates such as linting, tests and code review in place before merging. The course practises this workflow on a single project throughout its labs.
It suits developers already using an AI coding agent who want more out of it, full stack, frontend and backend developers, tech leads who set the team standard for working with agents, and DevOps engineers. You should be able to program in at least one language, have built a system with both a UI and a server side, use Git and the command line day to day, and have some experience of AI-assisted coding.
You will be able to choose and configure an agent to suit your team's work and budget, prepare context with AGENTS.md and team conventions, develop frontend and backend features with an agent in short iterations, extend it with MCP, skills, subagents and hooks, set quality gates before merging and use agents for deployment and routine work. Participants who complete the training receive a Certificate of Completion with its own number, which can be verified online.
Bring a laptop with Node.js and Git already installed and permission to install further software, plus your own account for an AI coding agent. The course focuses on ways of working across the SDLC phases rather than on one particular tool, so it carries over to other agents. You take away a lab guide, context templates such as AGENTS.md and DESIGN.md, and sample source code for every lab.
Claude Code is not merely a tool for asking an AI to write code. It acts as an AI coding agent that understands project structure, reads files, edits source code, runs commands, tests the system and works alongside a real development workflow. Anyone still…
System analysis and design work burns more time on writing documents and drawing diagrams than on the design thinking itself. Getting the use cases complete, finishing the process flows, making the ER diagram match what was actually agreed, then writing the…
Most QA time disappears into repetitive work: writing test cases one by one from incomplete documentation, preparing test data set by set, chasing scripts that broke because a screen changed slightly, and then summarizing results for the team. When time runs…
