Code Is No Longer the Bottleneck: Anthropic's AI-Native SDLC Playbook, Broken Down Stage by Stage

Forum topic · QianXun · 2026-08-28

Summary

This post is a full Chinese translation of Anthropic's Applied AI team playbook on building an AI-native software development lifecycle (SDLC) with Claude Code and Claude Enterprise. The core argument: once AI collapses the cost of writing code, the bottleneck shifts to planning, review, testing, and deployment, which still run at human speed. The playbook reorganizes the traditional six SDLC stages—Plan, Design, Build, Test, Deploy, Maintain—around versioned deliverables (intent.md, spec.md, plan.md, diffs with tests, PRs with review verdicts, incident records), forming a chain that doubles as an audit trail. Each stage's "Play" covers what changes, prerequisites, implementation steps, governance considerations, and metrics. Key practices include capturing intent directly from idea owners, collapsing requirements and design into one agent session, using plan mode before any code is written, encoding institutional knowledge in CLAUDE.md and skills, enforcing policies with hooks, and layering agentic review with human sign-off reserved for critical code. The article includes example prompts, sample intent/plan/SKILL.md files, metrics for each stage, and guidance on integrating with legacy systems like Jira.

This forum post is a complete Chinese translation of Anthropic's Applied AI team playbook on the AI-native software development lifecycle (SDLC), authored by Louis Claxton (dated August 21, 2026, in the source). Due to length, below is a structured English summary of the key content.

Core thesis

Organizations now write code with AI at unprecedented speed, but surrounding processes (approvals, reviews, handoffs) still run at human pace. The bottleneck has moved to either side of the Build stage: planning, review/testing, and deployment.
Traditional SDLC controls assume humans execute every step and that code writing is the slowest, costliest phase—assumptions that no longer hold. Line-by-line code review breaks down when most of a diff is agent-produced.

The AI-native SDLC loop

The lifecycle becomes a loop rather than a linear flow. Each stage ends by committing a deliverable to version control; the next stage begins by reading it:

intent.md → spec.md → plan.md → diff + tests → PR + review verdict → incident records

This chain doubles as the audit trail. Humans remain accountable for judgment decisions; their attention moves to wherever review is needed (the "gates").

The six stage Plays (each covers: what changed, how to start, steps, governance, metrics)

01 — Plan

Idea owners brainstorm directly with Claude to produce an intent.md prototype spec in their own words; no formal notation required.
Prerequisites: Claude access for non-engineers, an agreed intent.md template, a shared versioned intent store (an intent/ directory in the product repo is sufficient initially).
The product owner reviews and accepts/rejects; the acceptance decision is recorded as a merge or closed review.
Metric: time from first conversation to committed intent.md (expected: weeks → hours); survival rate of accepted intents.

02 — Design

Requirements and design collapse into a single agent session, guided by organization skills covering brand, security, compliance, and UX. Front-end work can use Claude Design (beta), exporting to Claude Code.
Policies are applied at spec-writing time, not discovered weeks later in review.
Flagged concerns are resolved with policy owners before engineering sees the spec.
Metric: wall-clock time between intent.md and spec.md commits; requirements rework after build starts.

03 — Build

Plan mode as the default start: no implementation without an accepted plan. The engineer interrogates and iterates the plan until another engineer could implement from it; the approved version is committed as plan.md.
Auto mode: with mature guardrails (tuned CLAUDE.md, policy skills, blocking hooks, self-runnable tests), auto-accept becomes the default for routine work, enabling long autonomous sessions and parallelism via git worktrees.
Sidebar — legacy systems: designate a single source of truth per deliverable (repo, legacy system like Jira, or bidirectional links with commit SHAs).
CLAUDE.md: institutional knowledge as a file agents read at every session start; rule of thumb—same mistake twice means a fix goes into CLAUDE.md; keep it under one page.
Skills: encode knowledge that must be applied consistently (e.g., .claude/skills/secure-api-review/SKILL.md with API security rules). Skills are persuasive controls; deterministic enforcement requires hooks.
Hooks: build-time guardrails—block edits to protected paths, run formatters/linters, keep credentials out of diffs. Human-approval hooks belong to the Deploy gates, not mid-build.
Parallel sessions and subagents: multiple Claude Code instances in separate worktrees; scoped subagents (verifiers, researchers, simplifiers) defined in .claude/agents/ markdown files.

04 — Test

Continuous evals woven into implementation replace stage-boundary QA gates (section truncated in source).

05 — Deploy

Layered agentic review with human review reserved for regulated and critical code; governance executes at the moment of AI action, with hooks acting as approval gates; CI/CD pipelines triggered by merged PRs (section truncated in source).

06 — Maintain

Agents monitor production; any breached control band is diagnosed and written back into the loop as a new intent.md (section truncated in source).

Adoption guidance

Plays are modular and non-linear; arrows in the playbook show adoption order, not stage order. Start with any "clay" Play that has no prerequisites.
Initially, manually prompt each step; the end state is a loop where each accepted deliverable fires the next gate, and human attention concentrates on what review agents flag.