# The AI-native software development lifecycle

URL: https://developertoolkit.ai/en/method/lifecycle/
Description: Run plan, design, build, test, deploy, and maintain as one loop: each stage commits an artifact, gates check evidence, and a named human signs off.

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](https://claude.com/blog/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](/en/method/lifecycle/tool-map/). Forrester calls the operating model around such a lifecycle [agentic software development](/en/glossary/agentic-software-development/).

## 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](/en/method/lifecycle/plan/) | `intent.md` in the originator's words | Problem, outcome, and constraints are stated; open questions listed | Product owner accepts intent |
| [Design](/en/method/lifecycle/design/) | `spec.md` with acceptance criteria | Each criterion is testable; policy skills applied and named | Tech lead approves the spec |
| [Build](/en/method/lifecycle/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](/en/method/lifecycle/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](/en/method/lifecycle/deploy/) | Pull request with review-agent findings | Findings resolved, CI green, and risk class set | Named reviewer merges; release owner promotes |
| [Maintain](/en/method/lifecycle/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](/en/ladder/evidence-not-diffs/) defines which ones. [AI-DLC](/en/glossary/ai-dlc/) pairs human approval gates with a committed audit trail in the same way; a worked run of one change is in [frameworks with audit trails and standards](/en/ecosystem/frameworks/enterprise-frameworks/).

## 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**

```text
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**

```text
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](/en/method/principles/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](/en/method/lifecycle/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](/en/method/lifecycle/metrics/).

## Lifecycle guides: artifacts, tools, metrics, and rollout

- [The artifact chain](/en/method/lifecycle/artifact-chain/) — The files each stage commits, and one source of truth for each.
- [Tool map](/en/method/lifecycle/tool-map/) — Every play mapped to Claude Code, Codex, and Cursor.
- [Metrics](/en/method/lifecycle/metrics/) — Leading and lagging indicators per play, read from git, PRs, CI, and incidents.
- [Adoption roadmap](/en/teams/adopt/adoption-roadmap/) — Roll the loop out across a repository, one transition at a time.
- [Governance and autonomy](/en/org/governance-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](/en/ladder/one-map/), then walk a feature through [the artifact chain](/en/method/lifecycle/artifact-chain/). For per-tool setup, use the [Claude Code](/en/claude-code/), [Codex](/en/codex/), and [Cursor](/en/cursor-ide/) sections.
