The AI-native software development lifecycle

The AI-native SDLC is one evidence-producing loop shared by Claude Code, Cursor, and Codex: plan, design, build, test, deploy, and maintain. Each stage commits an artifact the next stage can consume, while named humans retain product, architecture, merge, and production authority. Start with the adoption roadmap, then follow the artifact chain.

The traditional SDLC was built for an era when writing code was the slow, expensive step. Product managers wrote requirements, architects designed, engineers implemented, QA verified, release teams shipped, and operations watched production. Each handoff existed to force alignment during weeks of implementation.

Agentic coding collapsed that middle. A well-specified change can go from plan to passing tests in hours. The bottleneck moved to the human-speed steps around build: planning, review, test, and deploy. Line-by-line review cannot keep up once agents write most of the diff. Governance that still routes exceptions through weekly committees taxes every gain the agents just made.

The AI-native SDLC keeps the old control objectives and changes how they are enforced. The process is a loop. AI is embedded at every stage. Each stage ends by committing an artifact the next stage can read. Humans stay accountable for judgment; their attention moves to the gates, not to every generated line.

You will also hear this called the agentic SDLC or AI SDLC. The labels differ; the process is the same.

Source

The process in this section follows The AI-native SDLC playbook from Anthropic (August 2026). The plays are tool-agnostic. Claude Code, Cursor, and Codex each map onto the same artifacts — see the tool map.

What changes at each stage

The following table shows the ends of the spectrum. Most teams sit somewhere between the two columns.

Stage	Traditional SDLC	AI-native SDLC
Plan	Requirements gathered by committee, written up by hand	The originator captures intent as intent.md — human-readable and machine-actionable
Design	Spec written by analysts, parsed by designers	Requirements and design collapse into one session, constrained by versioned skills
Build	Tests and code handwritten; docs written after	Tests and code generated by the agent; institutional knowledge lives in CLAUDE.md, .cursor/rules, or AGENTS.md
Test	QA gates at stage boundaries	Continuous evals woven through implementation; the session checks its own work
Deploy	Humans review every line; governance in review cycles	Layered agentic review; human review for regulated and critical code; hooks as approval gates
Maintain	Humans watch production for bugs	Agents monitor live deployments; a breached control band writes the next intent.md

The thread through the right-hand column is the committed artifact. For early stages that is a markdown file a product owner and an agent can both read. From build onward the artifact is code and its records. The chain of commits is the audit trail: who asked for what, what the agent produced, and who approved it.

Delegate, review, own

At every stage the same split applies:

• Delegate — the mechanical first pass (boilerplate, a draft spec, a first review, log triage)
• Review — completeness, security, domain fit
• Own — priorities, architecture, UX, merge, production sign-off

Humans remain accountable for every decision that requires judgment. Agent output that looks confident is still a draft until a named human accepts it at the gate.

How the stages connect

A stage ends by committing an artifact. That commit is what starts the next stage:

1. An accepted intent.md triggers the requirements and design pass.
2. An approved spec.md triggers plan mode.
3. An accepted plan.md triggers implementation.
4. A merged pull request triggers the pipeline.
5. A breached control band in production writes the next intent.md.

You can start by prompting each step by hand. The end state is a loop in which each accepted artifact fires the next gate. Human attention concentrates at the gates, reviewing what the agent flagged rather than starting each stage from scratch.

The plays are modular. Adopt any play that has no prerequisite first (intent.md, CLAUDE.md / rules / AGENTS.md, skills, the feedback loop, hooks). For any other play, adopt the plays that feed it first.

Pages in this section

Adoption roadmap Move from a baseline to a closed loop in five independently shippable waves.

The artifact chain intent.md → spec.md → plan.md → diff and tests → PR findings → incident record. Name one source of truth.

Plan Capture intent in the originator's own words as a version-controlled proto-spec.

Design Turn accepted intent into spec.md, with policy applied while the spec is written.

Build Plan mode first, then implementation. Institutional knowledge as files. Guardrails as code.

Test Give the session a feedback loop. Regression-test the harness that steers the agent.

Deploy Layered agent review, hooks as approval gates, and a production gate the agent cannot pass.

Maintain Close the loop: a trigger writes the next intent.md. Scheduled scans and on-call.

Governance and autonomy Set risk tiers, identities, permissions, evidence, and the actions an agent may never take.

Tool map Every play mapped to Claude Code, Cursor, and Codex primitives.

Metrics Leading and lagging indicators per play, read from git, PRs, CI, and incidents.

Tool-specific SDLC tracks

Use these compact adapters after learning the canonical lifecycle above. They map the same artifacts and gates to each tool without duplicating the process guidance.

Claude Code adapter Plan mode, CLAUDE.md, skills, hooks, worktrees, and headless CI

Cursor adapter Plan and Agent modes, rules, skills, worktrees, Bugbot, and Cloud Agents

Codex adapter Plan mode, AGENTS.md, skills, hooks, app worktrees, exec, and review

Related

• PRD to Plan to Todo — the conversation that produces the early artifacts
• Human in the loop — where human attention sits once agents write most of the diff
• Design pipeline — the UI-specific path from brief to implementation