The AI-native SDLC playbook - Claude Academy
Claude Academy: The AI-native SDLC playbook
What is it?
A 14-lesson playbook from Anthropic's Applied AI team for running a software lifecycle where agents write most of the code. The premise is that the build phase collapsed to agent speed while the stages on either side of it (plan, review, deploy) still run at human speed, so the bottleneck simply moved. The fix on offer isn't more process. It's making every stage end by committing a file that the next stage reads.
What is it, more precisely?
Six stages arranged as a loop rather than a line: Plan, Design, Build, Test, Deploy, Maintain. Each hands off through a committed artifact.
intent.md: what is wanted, why, under which constraints. Enters as somebody's idea, a filed ticket, or a production alert.spec.md: requirements and design in one working session, guided by the organization's skills for brand, security, compliance and UX. The product owner reviews it rather than writing it.plan.md: the approved spec run through plan mode before any code is touched.- the diff and its tests: generated, with a feedback loop so the session verifies its own work before an engineer sees it.
- the PR and its review findings: layered agentic review, with human review reserved for critical and regulated code.
- the incident record: a breached control band in production gets diagnosed and written back out as the next
intent.md.
Two artifacts sit underneath the chain rather than inside it, read at the start of every session:
CLAUDE.md: conventions, commands, architecture, and the mistakes the team keeps making. What a new joiner would need on day one.- Skills: organizational standards encoded once and applied everywhere.
flowchart TD
accTitle: The AI-native SDLC artifact loop
accDescr: intent.md leads to spec.md, then plan.md, then the diff and its tests, then the PR and its findings, through an approval gate to production. A production incident record writes the next intent.md, closing the loop. CLAUDE.md and skills are read by every session.
intent["<b>intent.md</b><br/>what, why, constraints"]
spec["<b>spec.md</b><br/>requirements + design"]
plan["<b>plan.md</b>"]
build["diff + tests"]
pr["PR + review findings"]
gate{"approval gate"}
prod["production"]
incident["incident record"]
base["CLAUDE.md + skills"]
intent --> spec
spec --> plan
plan --> build
build --> pr
pr --> gate
gate -->|"merge"| prod
prod --> incident
incident -->|"breached control band"| intent
intent ~~~ base
base -.->|"read by every session"| plan
base -.-> buildWho owns what
The playbook doesn't publish a RACI. This is my reading of one, because "the agent does it" is not an answer to who is on the hook.
| Artifact | Responsible | Accountable | Consulted |
|---|---|---|---|
intent.md |
Claude, from an idea, ticket or alert | Product owner, who accepts it | Whoever raised the need |
spec.md |
Claude, in one working session | Product owner, who reviews but does not write | Security, compliance, UX, encoded as skills |
plan.md |
Claude in plan mode | The engineer steering the session | CLAUDE.md conventions |
| diff and tests | Claude sessions, self-verified through a feedback loop | The engineer steering the session | Subagents running the final check |
| PR and findings | Layered agentic review | Human reviewer, mandatory on critical and regulated code | Security for protected paths |
| Deployment | The pipeline, running Claude non-interactively | The named approver behind the hook gate | Engineering leadership and change management, who define which gates survive |
| Incident record | Agents monitoring live deployments | On-call engineer | Product owner, since it becomes the next intent.md |
The pattern is the interesting part. The R column moves to the agent at every single stage. The A column never moves at all. That is the actual shape of the change, and it is less comfortable than it sounds: being accountable for work you didn't do is the definition of a review burden, and reviewing is the thing that doesn't get faster.
Markdown dominates the early stages for a concrete reason: a product owner and an agent can both read and act on the same file. From Build onward the artifact is code and its records. The chain of commits doubles as the audit trail: who asked for what, what the agent produced, who approved it.
What it isn't
- Not a linear pipeline with AI bolted onto each phase. The loop is the whole idea; an accepted artifact fires the next gate.
- Not autonomy. Humans stay accountable for every decision requiring judgment. Attention moves to the gates instead of disappearing.
- Not a thing you adopt whole. The plays are modular and carry a dependency graph, and several have no prerequisites at all.
- Not written for me. The stated audience is engineering, platform and security leads at large regulated enterprises whose review queues are already backing up.
What I wish it could do
Say more about the small end. I run one-person projects, and the artifact discipline is obviously right at that scale too, but the governance apparatus around it, the approval gates and change tickets and control bands, is dead weight when the reviewer and the author are the same person. I'd like the version of this that keeps the handoff chain and drops the committee. When one person holds every row of that RACI, the table stops being a control and becomes a checklist.
I'd also like something on what happens when the artifacts disagree with the code. A spec that drifts from what shipped is the oldest failure mode in software, and moving it into version control makes it more visible without making it self-correcting.
What I'm still not sure of
Whether the .md files stay honest. Documentation rotted historically because it was written after the work and nothing depended on it. Here the file is the trigger, which is a much better incentive. But an agent will happily generate a plausible spec.md from a thin intent.md, and the cost of skimming one is low enough that skimming becomes the norm. The gate only works if somebody actually reads at the gate.
I'm also unsure how much of the benefit is the process versus the forced articulation. Writing down what you want, before building, has always worked. This might be the same old advice with a commit hook attached. That would still be worth it, just a less novel claim than the framing suggests.