The field guide · AI across the lifecycle
The AI SDLC — often called the AI-native SDLC — is the software development lifecycle with AI working at every stage: planning, requirements, design, coding, testing, deployment, and operations. Humans set intent and own quality; AI carries a growing share of the execution. This page walks the lifecycle stage by stage: what AI actually does in each, what changes in your process, and where assistance ends and delegation begins.
of new production code industry-wide is AI-generated
every one of them now has a working AI pattern
individual task output with AI assistants — org delivery stays flat unmanaged
program-level velocity in a managed first year — compounding after
The teams that build with Deop
What is the AI SDLC?
Every model of the SDLC — waterfall, agile, DevOps — runs the same seven stages: planning, requirements analysis, design, implementation, testing, deployment, and maintenance. The AI SDLC isn't a new model; it's what happens to those stages when AI joins the work.
In the first era, AI assisted: autocomplete in the editor, a chat window for questions. In the current era, AI executes: coding agents take scoped issues, testing agents backfill coverage, operations agents triage incidents — all behind the same review bar as everyone else. That second era has a name of its own: the agentic SDLC.
The line that matters
Era 1 · Assistance
Autocomplete in the editor
A chat window for questions
The human stays the author
Changes stage 4 only
Individual gains, flat delivery
Where most teams are today
→
Era 2 · Delegation
Coding agents take scoped issues, work in their own environment, and open PRs behind one review bar
Testing agents backfill coverage; operations agents triage incidents and propose the fix
Changes all seven stages — work definition, review capacity, and governance become the constraints
→
What humans keep
✓ Intent — what to build and why
✓ Verification — one review bar for all code
✓ Risk — governance, provenance, freeze rules
✓ Quality — the standards agents build to
The managed path between the eras —
assess · baseline · pilot · gate on evidence · scale
— is what DeopShift packages
The evidence
+21% individual task output is real. Organizational delivery on unmanaged rollouts is roughly flat. The gap lives between the stages — and closing it is the whole point of an AI SDLC.
Autocomplete accelerates typing, not delivery
Gains pool in individuals, not in flow
Org-level lift requires process redesign
This gap is the entire adoption problem
Where AI is dramatic today: well-scoped, verifiable work with clear success criteria — which is why the implementation and testing stages moved first.
Test backfills and coverage lifts
Documentation and doc-drift repair
Dependency bumps and mechanical migrations
Small features against a written spec
The honest program-level number for a managed first year — compounding as specs, gates, and delegation share mature across the lifecycle.
Grows with delegation share, not seat count
Compounds through failure-clinic discipline
Leading indicators move first: review latency, PR size
Scale decisions belong on your data, not benchmarks
The industry-wide share of new production code — which makes the review and deployment stages the binding constraint.
Review latency is the new bottleneck
One review bar for human and agent code
Provenance and audit trails in regulated work
Change failure rate is the safety gate
The seven stages · 1–4
Delivered with
+
1
AI drafts epics from product intent, sizes work against repo history, and flags dependency risk. The human call stays the human call: what to build and why.
2
Specs become executable. Spec-driven development — GitHub Spec Kit: constitution → specify → plan → tasks — turns requirements into the source of truth both humans and agents build from. The highest-leverage AI-SDLC practice.
3
AI proposes architectures against your ADRs and conventions, surfaces prior art from the codebase, and stress-tests designs before a line is written. Instructions files make house style machine-readable.
4
The stage that moved first and furthest: from autocomplete to coding agents that take an assigned issue and open a pull request. Task-level gains of 46–90% on well-scoped, verifiable work.
The stack
On the Microsoft stack the lifecycle is covered end to end: GitHub Copilot for in-editor assistance, the Copilot coding agent and Agent HQ for delegation, Spec Kit for executable requirements, Actions and branch protection for deterministic gates, and Azure AI Foundry for building AI into your own products.
Plan & specify
Copilot in issues · Spec Kit: constitution → specify → plan → tasks
Build & verify
coding agents on scoped issues · Actions CI · branch protection as the one review bar
Ship & operate
change-risk scoring · progressive delivery · monitoring agents that open the fix PR
↻ Operations feeds planning — the lifecycle stops being a line and becomes a loop
The seven stages · 5–7
Agents generate and maintain test suites, lift coverage, repair doc drift, and triage CI failures. Deterministic gates do the enforcing: “follow our standards” in a prompt is probabilistic; a linter that blocks the PR is not.
AI-assisted release notes, change-risk scoring, and progressive-delivery decisions — with provenance intact, because security’s first question about AI-authored code is “who wrote this and why.”
Monitoring agents summarize incidents, propose rollbacks, and open the fix PR that feeds straight back to planning. Stage seven ends where stage one begins.
Governance & measurement
DORA: lead time, deploy frequency, change failure rate, MTTR
DX: speed, effectiveness, quality, impact — baselined before rollout
individual-level metrics — team scorecards only
“Baseline first. Delegation expands only on evidence — where change failure rate holds. One review bar for human and agent code, at every stage of the lifecycle.”
Plain answers
AI SDLC (or AI-native SDLC) is the software development lifecycle with AI integrated across every stage — planning, requirements, design, coding, testing, deployment, and operations. Humans set intent and own quality; AI carries a growing share of execution, from in-editor assistance to autonomous agents working under governance.
Planning, requirements analysis, design, implementation, testing, deployment, and maintenance/operations. AI now has a working pattern in every one — drafting plans, executing specs, writing and testing code, scoring release risk, and triaging incidents — without changing what each stage is for.
AI SDLC is the umbrella: AI anywhere in the lifecycle, including simple assistance. Agentic SDLC is its current stage: autonomous agents executing whole tasks — taking issues, opening pull requests — behind the same review bar as humans. Every agentic SDLC is an AI SDLC; not every AI SDLC is agentic yet.
At the task level, dramatically — 46–90% on well-scoped, verifiable work. At the program level, only when managed: ~5–10% in a governed first year, compounding as instructions files, gates, and delegation share mature. Unmanaged rollouts show individual gains and flat organizational delivery.
GitHub Copilot (autocomplete and chat), the Copilot coding agent and Agent HQ (delegation), GitHub Spec Kit (spec-driven development), Actions and branch protection (deterministic gates), and Azure AI Foundry for building AI into your own products — one stack from planning through operations.
Baseline first, then gate every expansion on evidence: DORA four keys plus DX Core 4 at the team level, delegation expanding only where change failure rate holds. That assessment-first, quality-gated path is what DeopShift packages — starting with a two-week assessment.
A two-week, fixed-fee assessment maps AI across your seven stages, places every team on the maturity model, and hands you a 90-day roadmap — yours to keep either way.
Book a discovery →