A
The AI-native SDLC loop
0%

The AI-native SDLC loop

Anthropic published a forty-minute playbook for building software with agents. I read it from the operator's seat and turned it into a loop you can scroll. One request, six stages, about two minutes.

Allyn Shaw, October 2026

↓ nextorpress play and watch it run

The six stages didn't change. The cycle did.

Plan, design, build, test, deploy, maintain. Anthropic kept all six and rebuilt what happens between them around agents. The stages are familiar. The handoffs are not.

They kept seeing the same problem.

Anthropic's applied AI team sits with companies running Claude Code. Every one of them hit the same wall, and I recognize it from my own seat.

Build stopped being the slow part.

Agents write code in hours. Six weeks became an afternoon. That part needed no convincing.

Everything around it still runs at human speed.

Planning, review and deployment didn't get faster. The bottleneck didn't disappear. It moved, from the engineer's keyboard to the reviewer's queue.

The queue is where it shows.

Agents open pull requests faster than one reviewer can read them. Either the queue grows or code goes out under-reviewed. Neither is a plan.

So they rebuilt the process. A loop, not a line.

The row of handoffs and sign-offs becomes a cycle that feeds itself. The humans don't leave. They move to the gates.

Every stage leaves a file in git.

That file starts the next stage. An intent, a spec, a plan, the code, a reviewed pull request, a new intent when something breaks. Read it once as a workflow. Then read it again as an audit trail nobody had to assemble.

Follow one request.

A note from fraud operations: customers want to confirm a blocked card payment in the app instead of calling. Twenty thousand calls a month to say "yes, that was me."

Step one: plan.

The old way: backlog entry, user story, story points, refinement meeting, sign-off. Three weeks before anyone writes a line, and most of it is waiting for a room.

Whoever has the idea talks to Claude.

It asks who's affected and what the limits are, then writes the brief. No ticket, no template. Ten minutes and a person who knows the problem.

The brief is intent.md.

Problem, outcome, constraints, open questions. One page, plain language. If it doesn't fit on a page, it isn't ready for a decision.

A human approves it.

The product owner signs, the file commits, and the name is on the record. Three weeks become four hours.

Step two: design.

Claude turns the brief into the full spec. Requirements, security, design. That's spec.md, drafted in minutes, which only matters if the rules go in with it.

The company's rules apply while it writes.

Security, brand and UX policy are packaged as skills. The spec follows them as it's written, not in a review six weeks later. Policy at the point of work.

Problems get flagged now, not in week six.

The draft wants to show the fraud model's score so customers see why a payment was blocked. That also tells fraudsters how the model decides. It goes to the policy owner before an engineer ever sees the spec.

Step three: build.

Claude Code writes plan.md first. In plan mode it can read the whole repo and can't change a file. Read everything, touch nothing, until a person says so.

An engineer approves the plan.

Files, order, risks, and how the work will be proven. Only then can it edit. The plan has to be readable in minutes, because the engineer is now the slowest part of the stage.

Every session starts by reading CLAUDE.md.

The team's commands, conventions and past mistakes, kept under a page. Money is BigDecimal, never double. The v1 directory is frozen. Institutional memory, written down for once.

One engineer runs three sessions at once.

Each in its own worktree. The engineer steers. Two or three is the ceiling, and I'd hold people to it. Past that you're not steering, you're watching.

What stops it going rogue? Two layers.

Skills are rules the agent follows. Most of the time. Most of the time is not a control.

Hooks are scripts that block unsafe actions.

Every time. A pre-tool-use hook refuses the edit to a frozen file or the command that prints a secret, and tells Claude why. The unsafe action never runs.

Skills make mistakes rare. Hooks make them impossible.

Policy as instructions, then policy as code. Only one of those is a control I'd put my name on.

Step four: test.

Claude checks its own work. Run the tests, fix, run again, until it's green. The loop is boring, which is exactly what you want from a loop.

The evidence goes on the pull request.

Forty-two passed, output attached. A suite of 20 to 50 real tasks runs as evals in CI, and the pass rate gates the merge. Control testing on every change, not a quarterly sample.

No cheating the tests.

A hook locks the test files while a fix is in progress. A failing test can't be made to pass by rewriting it. The temptation is older than agents.

Step five: deploy.

Claude reviews every pull request in three passes: bugs, security, and whether the code matches spec.md and plan.md. The review reads the files the loop wrote.

It can never approve its own code.

The author can't approve. A code owner keeps the merge button. Segregation of duties, and nobody had to write a policy to get it.

Production stays locked.

The agent deploys freely to dev. Staging sits in between. Prod opens only when a release manager signs off. Autonomy by environment, earned a gate at a time.

Step six: maintain. 3 a.m., errors spike.

Detection is deterministic: a control band on a 30-day baseline. No model decides whether something is wrong. That line matters more than it looks.

A script calls Claude.

One sigma, log it. Two, diagnose with read-only tools. Three, propose a fix. The service owner triages in the morning: fix now, schedule, or dismiss. The agent proposes. A person decides.

Claude finds the cause and writes a new intent.md.

The fraud engine was re-scoring every confirmation, uncached, and timing out. The finding lands in the triage queue as the next request, and the incident becomes a permanent eval. Same mistake, never twice.

The loop restarts itself.

Weekly security scans and an on-call agent in Slack feed the same queue. Nothing waits for a planning cycle.

Every step left a commit.

Who asked. What the agent built. Who approved. The audit trail is the git history, and nobody assembled it the week before an exam.

Who holds each gate.

A product owner on the intent. A policy owner on anything flagged. An engineer on the plan. Evals in CI on the merge, a code owner on the button, a release manager on production. A service owner on what gets fixed. Six decisions, one owner each. Agents do the work in between.

Code got cheap. Judgment didn't.

The loop keeps running. What's scarce now is a person who can approve well, fast, on evidence. That's a skill to hire for, and this loop makes it visible.

Which stage is slowest where you work?