The AI-native software development lifecycle

The AI-native software development lifecycle (SDLC) runs plan, design, build, test, deploy, and maintain as one loop in which every stage commits an artifact the next stage reads: intent.md, spec.md, plan.md, the diff with its tests, the reviewed pull request, and the incident record. Agents do the first pass at each stage; named humans own the gates.

This page is for the developer, tech lead, or CTO whose agents now produce a working diff in an afternoon, while the ticket still took a week to write and the pull request still waits two days for review. Build stopped being the slow step; the human-speed steps around it did not. Rebuilding those steps is what this section covers.

The process follows The AI-native SDLC playbook (Anthropic, 21 August 2026). The artifacts are plain files, so Claude Code, Codex, and Cursor all fit the same loop — see the tool map.

What each lifecycle stage commits, and who signs it off

Each row is one stage. The artifact is what the stage commits; the evidence column is how the gate is checked without a human reading every generated line.

Stage	Artifact committed	Evidence the gate checks	Human who owns the gate
Plan	intent.md in the originator’s words	Problem, outcome, and constraints are stated; open questions listed	Product owner accepts intent
Design	spec.md with acceptance criteria	Each criterion is testable; policy skills applied and named	Tech lead approves the spec
Build	plan.md, then the diff and its tests	Diff matches the plan’s file list; new tests fail before the change	Engineer accepts the plan
Test	Test and lint output attached to the change	The session ran the project’s check command and pasted the result	Automated; engineer reads failures only
Deploy	Pull request with review-agent findings	Findings resolved, CI green, and risk class set	Named reviewer merges; release owner promotes
Maintain	Incident record and the next intent.md	A deterministic alert fired; evidence gathered read-only	On-call engineer accepts the new intent

The chain of commits is also the audit trail: who asked for what, what the agent produced, and who approved it. Human review of the code itself stays for regulated and critical changes; reading evidence instead of code defines which ones.

Start the loop on your next change

The playbook breaks each stage into plays — one practice each — and the plays are modular. Five have no prerequisites: intent.md, the instructions file (CLAUDE.md or AGENTS.md, or Cursor rules), skills, the session feedback loop, and hooks as approval gates. Start there on one real change.

1. Pick one change that is already in your backlog and small enough to merge this week.

2. Turn the ticket into intent.md with the first prompt below, then have the person who asked for the change accept it.

3. Enter plan mode, ask for a plan that names the files, the order of work, and the tests that prove it, and commit the accepted plan as plan.md.

   Claude Code

   Start with claude --permission-mode plan, or type /plan in a running session.

   Codex

   Type /plan in the Codex terminal UI to switch to Plan mode before the run starts.

   Cursor

   Switch the agent to Plan Mode before you describe the change.

4. Tell the agent the one command that proves the change — for example npm run typecheck && npm run lint && npm test — and require its output before it reports done.

5. Open the pull request with the artifacts linked, run a review agent, and merge only after a named human accepts the evidence.

   Claude Code

   Run /code-review in the session. For a deeper pass, run claude ultrareview from the shell.

   Codex

   Type /review in the Codex terminal UI, or run codex exec review in CI.

   Cursor

   Let Bugbot review the pull request.

Copy-paste prompt: turn a ticket into intent.md

Read the ticket text I paste below. Do not propose a solution yet.
Write intent.md with these sections: Problem (in the requester's words),
Proposed outcome, Affected users and systems, Constraints, Open questions.
Quote the ticket wherever you can instead of paraphrasing it.
List every assumption you made under Open questions, and stop.
Ticket:

Copy-paste prompt: find where your lifecycle stalls

Audit this repository against a six-stage lifecycle: plan, design, build,
test, deploy, maintain. For each stage report: the artifact that exists
today (file path, or "none"), the command or CI job that checks it, and
who approves it according to CODEOWNERS, branch protection, or the PR
template. Use only what you can find in the repository and git history.
End with the single stage that has no committed artifact or no automated
check, and propose the smallest change that adds one.

Delegate, review, own at every stage

Across all six stages, split the work three ways:

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

Agent output that looks confident is still a draft until a named human accepts it at the gate. Human in the loop covers where that attention belongs.

What breaks when a team adopts the AI-native lifecycle?

• Artifacts are written and never read. plan.md drifts from the diff within a week. Recovery: update plan.md in the same commit as the code, and have the review agent check the diff against the plan.
• Automation lands before the gates. Agents in CI push changes through a pipeline with no hooks and no review agent. Recovery: adopt hooks and pull request review first; the playbook lists them as prerequisites for pipeline automation.
• Two sources of truth. Jira says one thing, spec.md another. Recovery: name one system as the source of truth per artifact, or at minimum link the record ID and the commit SHA both ways (the artifact chain shows the three options).
• Gates become rubber stamps. Approvals arrive in seconds. Recovery: make each gate check the evidence column above, and track it with SDLC metrics.

Lifecycle guides: artifacts, tools, metrics, and rollout

The artifact chain The files each stage commits, and one source of truth for each.

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

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

Adoption roadmap Roll the loop out across a repository, one transition at a time.

Governance and autonomy Risk tiers, identities, permissions, and the actions an agent may never take.

Where to go next with the lifecycle

Place the lifecycle against the autonomy ladder first in one map, then walk a feature through the artifact chain. For per-tool setup, use the Claude Code, Codex, and Cursor sections.