The AI SDLC is the software development lifecycle (SDLC) redesigned for a team where coding agents write most of the code. Planning turns into specifications agents can execute, and review, testing and release become the stages that decide how fast anything ships.
The stages that break first are the ones built to inspect human-sized changes at human pace. An agent can open a pull request in minutes, then wait a day for a reviewer and a slot on shared staging. The complete guide to software factories explains that mismatch as a control problem, with the industry data behind it.
For an engineering leader, the useful question is narrower: which stages to redesign first, and in what order. The short answer is testing, then review, then release.
What is the AI SDLC?
The AI software development lifecycle, also called the agentic SDLC or the AI-native SDLC, is a lifecycle whose stages assume agents do most of the writing and people decide what ships. That’s different from adding an assistant to the lifecycle you already run.
Most teams start with AI in the software development lifecycle they already have. That’s AI-assisted development: it keeps the old stages and speeds up one step inside them, usually typing code. The review queue, the test environments and the release train stay sized for the old volume. AI-native engineering changes the stages themselves, because every stage after coding now receives changes at the rate agents produce them.
AWS’s AI-Driven Development Life Cycle (AI-DLC), published in July 2025, is one worked-out version. It splits the work into Inception, Construction and Operations, and replaces sprints with short cycles it calls bolts, measured in hours or days. At each step the agent proposes a plan, asks clarifying questions, and proceeds only after a person approves.
Whatever framework you adopt, the shape is the same. Intent goes in as specifications, agents generate the code and tests, and the checks that decide what merges have to run at the agent’s pace.
Which SDLC stages break first when agents write the code?
Testing and review break first, then release. Each was sized for a team where a person wrote a few changes a day and could afford to wait for an answer. This is where the pressure lands.
| Stage | What it assumed | What breaks with agents | What to redesign |
|---|---|---|---|
| Plan | Tickets a person interprets | Agents build exactly what an ambiguous ticket says | Specifications and acceptance scenarios an agent works from |
| Code | Writing is the slow step | Nothing: this is the step agents speed up | Context, tools and rules for your codebase |
| Review | A person reads every line | Queues grow, and large diffs get skimmed | Review intent and evidence, not every line |
| Test | Shared staging, after merge or on a schedule | Agents wait hours, or ship on mocks | A production-like environment per change, before review |
| Release | A few changes per deploy | More changes per deploy, harder rollback | Smaller batches and progressive delivery |
| Operate | Every incident traces to a person's change | Ownership of agent changes is unclear | A named owner for every agent change |
Coding is the one stage that needs no redesign to go faster. The rest of the lifecycle has to catch up with it.
Why code review becomes the constraint
Code review becomes the constraint because every agent change still needs a person’s attention, and attention doesn’t scale with the number of agents. The queue in front of reviewers is the first one to grow.
LinearB’s 2026 benchmarks, drawn from 8.1 million pull requests across 4,800 teams, show what that looks like. AI-generated pull requests waited more than 16 hours on average before a reviewer picked them up, against about 200 minutes for unassisted work. Only 32.7% of them merged within 30 days, against 84.5% for unassisted pull requests (LinearB). LinearB sells engineering analytics, so read these as one vendor’s customer base rather than a census.
The redesign changes what a reviewer reads. Nobody can check a large agent diff line by line at agent volume, but a person can check intent: does the change do what the specification asked, and does the evidence show it works? That only holds if every pull request arrives with results from a production-like test run, so the reviewer’s time goes to design and risk.
In practice, three rules carry most of the change. Ask agents for smaller pull requests, since splitting work costs an agent far less than it costs a person. Make the pull request template ask for the specification the change implements and the test results behind it. Let an AI review tool take the first pass on style and obvious defects, and keep the merge decision with a person.
Testing moves inside the agent’s loop
Testing moves from a stage after the pull request into the agent’s own loop. An agent that can run its change against the services it calls, in minutes, fixes most problems before a person sees them.
That’s the gap teams feel now. In Qodo’s 2026 survey of 500 U.S. developers and 300 engineering leaders, both groups named reviewing and verifying agent output as their main delivery bottleneck. Only 3.7% of the leaders said their current processes could maintain quality as agents take on more work (Qodo). Qodo sells AI code review, which is worth keeping in mind with its numbers.
The fix is a production-like environment for every change, available to the agent before review. Shared staging can’t provide that: one environment serializes every change, and one broken deploy blocks everyone. A full copy of the stack per pull request works, but it costs too much and takes too long to provision at agent volume. Here is the difference in the flow.
This is what Signadot does. Each change gets a Sandbox, Signadot’s lightweight ephemeral environment, which runs only the services the change touched and shares the stable services already running in your Kubernetes cluster. Coding agents such as Claude Code, Cursor and Codex create and manage Sandboxes through the Signadot MCP server.
The signadot-validate agent skill then runs the tests the agent chose against its Sandbox and iterates until they pass. The guide to verifying AI-generated code on Kubernetes covers that loop in depth, and ephemeral environments for coding agents shows how teams set it up.
What changes for each team
Every team in the lifecycle keeps its job, but the job moves earlier or gets narrower. The change is biggest for the teams that used to absorb human-paced work.
- Platform engineering owns the environments agents verify in. Its product becomes a production-like environment any agent can create on demand, wired into CI and the agent’s tools, rather than one staging cluster to keep alive.
- Developers spend less time typing and more time writing specifications, checking intent and owning what their agents ship. A developer running three agents in parallel works more like a tech lead.
- QA moves from testing after merge to designing the acceptance scenarios agents test against. Those scenarios outlive any single change, so that’s where QA’s judgment compounds.
- SRE sees more and smaller deploys. Progressive delivery and fast rollback matter more, and so does knowing which agent change, and which person, is behind a failing release.
None of these roles disappears. Each one moves its checks to the point where agent changes pass through, and runs them at agent speed.
Planning becomes specifications, and release stays progressive
Planning changes from tickets a person interprets to specifications an agent can execute. An agent builds what the ticket says, so an ambiguous ticket becomes an ambiguous change, fast.
Spec-driven development tools such as GitHub Spec Kit and Kiro make the specification a file in the repo that agents plan and build from. Keep the acceptance scenarios somewhere the agent doesn’t edit, so it can’t rewrite a check in order to pass it.
Release changes less than people expect. Canary deployments, feature flags and fast rollback already handle many small changes. What grows is the volume, so keep batches small and give every agent change a named owner for when something breaks in production.
Where to start: a redesign order for engineering leaders
Start with the stage where agent changes wait longest. For most teams that’s testing, then review. A practical order:
- Measure where pull requests wait. Track review pickup time and merge rate for agent pull requests separately from human ones.
- Give every change its own production-like environment, so agents verify before review instead of queuing for staging.
- Require evidence in the pull request: which tests ran, against what, and with what result.
- Move intent into specifications, with acceptance scenarios the agent can’t edit.
- Raise agent volume one type of change at a time, once the stages above keep up.
The order matters. Adding agents before step 2 gives you more pull requests waiting on the same slow answer. Step 1 costs nothing: pull last month’s agent pull requests and look at where each one waited.
Frequently asked questions
How is the AI SDLC different from the traditional SDLC?
The traditional SDLC assumes people write the code, so its review, testing and release stages are sized for a few changes per engineer per day. The AI SDLC assumes agents write most changes while people set intent and approve results. Coding gets faster, and review, verification and release have to be rebuilt to keep up with agent volume without lowering the bar for what merges.
What is AWS's AI-DLC?
AI-DLC, the AI-Driven Development Life Cycle, is a methodology AWS published in July 2025. It organizes work into Inception, Construction and Operations phases. Agents propose plans, ask clarifying questions and generate requirements, code and tests, and people approve each step before work continues. It replaces sprints with short cycles AWS calls bolts, measured in hours or days rather than weeks.
Which part of the SDLC should we redesign first when agents write most of the code?
Start with testing, then review. Testing is usually where agent changes wait longest, on a shared staging environment or a nightly suite. Give each change a production-like environment the agent can use before it opens a pull request, then change review to check intent and test evidence. Release practices such as canaries and feature flags usually need tuning rather than a rebuild.
What does an agentic SDLC change about code review?
Reviewers stop being the first check that a change works and become the check that it does the right thing. At agent volume, nobody can read every line of every pull request. Each change should arrive with evidence from a production-like test run, so the reviewer spends time on design, risk and whether the change matches its specification.
Do you still need a staging environment in an AI-native SDLC?
Many teams keep one for final release checks, but it stops being where changes get verified. One shared environment serializes every change and breaks whenever a deploy goes wrong, which agent volume makes constant. Per-change lightweight ephemeral environments handle verification before merge, and staging, if you keep it, becomes a short pre-release step.