Key Takeaways
- Agents now act at every stage of the SDLC, from spec to production.
- 46% of developers distrust the accuracy of AI output (Stack Overflow, 2025).
- Verification should run apart from the coding agent, against the deployed app.
- Set agent authority and human checkpoints stage by stage.
The agentic SDLC is arriving faster than most teams' review and testing processes can absorb. In Google's 2025 DORA research, AI adoption among software development professionals reached 90%, and the 2025 DORA report describes AI's primary role as an amplifier of an organization's existing strengths and weaknesses. Published models of the agentic AI software development lifecycle, from AWS and Microsoft, among others, put agents at every stage. Most leave testing to the coding agent that wrote the change, or compress it into one line of a table. This guide maps each stage, the artifact it hands off, and where independent verification belongs.
What is the agentic SDLC?
The agentic SDLC is a software development lifecycle in which AI agents plan, write, review, test, and operate software, with defined authority at each stage. Humans set intent, approve key decisions, and own the release. Each stage produces an artifact that the next stage, human or agent, can act on.
For the broader concept, see our explainer on agentic development. "AI SDLC" is often used as an umbrella for both copilot-assisted and agent-led work. The table shows where they differ.
|
Stage |
Traditional SDLC |
AI-assisted SDLC (copilots) |
Agentic SDLC (agents act and hand off) |
|
Planning |
People write requirements and tickets |
AI drafts stories on request |
Agent proposes a spec and asks clarifying questions; people approve it |
|
Code |
Developers write the code |
Copilot suggests lines and functions |
Coding agent implements across files and opens a PR |
|
Review |
Peer review |
AI summarizes diffs |
AI review and static analysis flag issues; people own design and risk |
|
Testing |
QA team and CI suites |
AI suggests test cases |
Coding agent runs unit tests; an independent end-to-end verifier checks the deployed app |
|
Release |
Manual go/no-go |
Same process, faster inputs |
Automated gates paired with a release owner |
|
Operations |
On-call engineers |
AI answers log queries |
Operations agents watch production and feed incidents back into specs |
Stages of the agentic AI software development lifecycle
Planning and specification
Specs and acceptance criteria are the basis of what the agent works from, so vague requirements become vague code, built at machine speed. In the AI-Driven Development Life Cycle used by AWS, AI creates detailed work plans, asks clarifying questions, and defers critical decisions to people, who validate the plan before construction starts. Agents draft the spec and flag gaps, while humans still own scope, priorities, and the acceptance criteria.
Artifact handed off: an approved spec with testable acceptance criteria.
Code generation
Coding agents implement against the spec, often touching many files in one change, and writing unit tests as they go. Code moves quickly through this phase, but it often exposes security vulnerabilities. In Veracode's 2025 GenAI Code Security Report, 45% of AI-generated code samples failed security tests and introduced OWASP Top 10 vulnerabilities. For this reason, humans own the architecture boundaries and decide which repositories and secrets an agent can access.
Artifact handed off: a pull request with a diff and the agent's own unit tests.
Review
AI code review and static analysis catch style issues, known vulnerability patterns, and maintainability risks before a PR is opened. Microsoft's AI-led SDLC walkthrough describes this step as human in the loop with agent assistance. GitHub Code Quality flags risks, and a developer decides whether the change meets the requirements, so design and risk judgements stay with people
Artifact handed off: a reviewed PR.
Verification and testing
The coding agent's tests share its assumptions. If it misread the spec, its tests encode the same misreading and pass. In Microsoft's walkthrough, the coding agent runs the required tests and screenshots its own UI changes for the PR. That's useful, but the author is still checking its own work.
Independent verification derives tests from the spec instead of the diff. It runs them against the deployed application in a real browser and uses assertions the coding agent can't edit. End-to-end journeys cover what users actually do across services, and change-aware test selection runs the tests that touch the change first. This is the job of AI test automation that verifies what coding agents ship.
Artifact handed off: a release verdict with evidence.
Release
Automated gates confirm that verification passed, required approvals exist, and evidence is attached before a change deploys. Staged rollouts and feature flags limit how many users see a change first. Agents can draft release notes and rollout plans. One release owner makes the go/no-go call with the evidence in front of them, which is how teams release with confidence at agentic speed.
Artifact handed off: a deployed change with its approval record.
Operations and feedback
Operations agents watch production, correlate alerts, and propose fixes, as the Azure SRE Agent does in Microsoft's example. Every incident should feed back into a spec update and a new test, so the same failure can't ship twice. Measure the whole lifecycle with DORA's five software delivery metrics: change lead time, deployment frequency, failed deployment recovery time, change fail rate, and deployment rework rate. The last two show whether agent speed is producing rework.
Verification becomes the bottleneck
Code generation scales with compute. Review and testing scale with people and test infrastructure, so work queues up after the PR opens.
The trust data explains why teams can't skip that queue. In the Stack Overflow 2025 Developer Survey, 46% of developers said they actively distrust the accuracy of AI tools, compared with 33% who trust it. Perception is unreliable as well. In METR's study of experienced open-source developers, participants believed AI had sped them up by about 20%, while measured task time rose 19%.
Faster authoring moves the constraint downstream to validating the whole system: integrations, end-to-end user journeys, and regression coverage. In the past, we've written about the problem this creates, and about what happens when teams bypass gates to keep up when your ADLC is outrunning your quality gates.
Requirements for independent verification
Independent verification rests on one principle: the author cannot be the verifier. Building that separation takes more than a second prompt to the same agent, and our post on the verification gap in the AI-native SDLC covers why. Ensure any approach meets these requirements:
-
The verifier is separate from the code author. It runs in its own context with its own instructions, and the coding agent can't report a pass on its behalf.
-
Intent is captured before code is written. Acceptance criteria written during planning become the source of tests, so the diff can't redefine "correct."
-
Deterministic assertions sit alongside AI judgment. Fixed assertions handle what must be exact, such as totals and permissions, and AI evaluation handles non-deterministic output like generated text.
-
Every verdict carries evidence, including the steps run, screenshots, and logs, for passes as well as failures.
-
Verification scope follows risk. Workflows that include payment, login, or regulated flows get full end-to-end coverage on every change, while low-risk changes get a targeted run.
A testing harness is built to find the failures users would hit, while a coding harness rewards the agent for finishing its task. That's why the testing harness vs. coding harness question addresses why testing and verification must remain independent in the agentic SDLC.
Governance by stage
Set agent authority one stage at a time, and widen it only when the output matches your expectations.
|
Stage |
What agents may do on their own |
Human checkpoint |
Evidence kept |
|
Planning |
Draft specs, ask clarifying questions |
Product owner approves the spec and acceptance criteria |
Approved spec and its version history |
|
Code generation |
Implement in a branch, write unit tests |
Platform team scopes repository and secret access |
Diff and agent session log |
|
Review |
Flag issues, suggest fixes |
Reviewer approves design and risk |
Review comments and scan results |
|
Verification |
Run independent tests, triage failures |
QA or release owner reviews failed or skipped checks |
Test runs, screenshots, and logs |
|
Release |
Prepare notes and the rollout plan |
Release owner makes the go/no-go call |
Gate results and approval record |
|
Operations |
Detect, diagnose, and propose fixes |
On-call engineer approves production changes |
Incident timeline and the linked new test |
The Secure Software Development Framework (SSDF) from NIST gives a baseline of secure development practices to map these controls against. Skipping this work has a cost: Gartner predicts over 40% of agentic AI projects will be canceled by the end of 2027, citing escalating costs, unclear business value, and inadequate risk controls.
mabl's role in the agentic SDLC
mabl is the independent verification layer for agentic development, verifying code before merge. mabl runs end-to-end tests against a deployed application in a real browser, in a context separate from the coding agent, using assertions the team defines. This ensures the coding agent can't weaken a test to get a pass.
Through the mabl MCP server, coding agents can find and run the tests related to a change and investigate failures without leaving the IDE. Each run keeps screenshots, DOM snapshots, network logs, and the reasoning behind agentic actions as audit-ready test evidence, linked back to the requirement it supports.
First step: add an independent check to one pipeline
Pick one service where coding agents open frequent PRs. Run spec-derived end-to-end checks on every PR in report-only mode for a few sprints, and compare what they catch with what the coding agent's own tests caught. Make the check blocking once the signal holds up.
See how mabl helps you reduce risk while independently verifying releases in your agentic SDLC. Request a demo.
Frequently Asked Questions
What is an agentic SDLC?
An agentic SDLC is a software development lifecycle in which AI agents plan, write, review, test, and operate software, while people set intent, approve key decisions, and own releases. Each stage hands a defined artifact to the next, with agent authority set per stage.
The right mix depends on your workflow. Evaluate what each agent can access, which decisions it makes, and how its output gets verified.
How is the AI SDLC different from the traditional SDLC?
In the AI SDLC, AI acts at each stage instead of only assisting developers, so cycles are shorter and more code reaches review. That shifts weight to verification and governance: who checks agent output, against which criteria, and with what evidence.
A separate testing harness should provide the independent release verdict and supporting evidence. It evaluates the code using distinct objectives, context, and quality standards.
Should coding agents test their own code?
Yes, for unit tests during implementation, which catch obvious breaks early. Release decisions need verification separate from the author: tests derived from the spec, run against the deployed app, with assertions the coding agent can't change.
