a curious builder's notebook

All posts

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 -.-> build

Who 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.