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.