9 min read
Code Got Cheap. Accountability Didn't.
An AI-native delivery loop, from INTENT.md to human approval, and why the Definition of Done and accountability stay human. Part 2 of 3.
Part 2 of 3. Part 1 is Why AI Won’t Speed Up Your Scrum Team (The 1999 Trap). Part 3 is Why AI Is Breaking Your Definition of Done.
Short answers
In Part 1 the problem was that AI widens the top of the delivery funnel while review, QA and release stay at human speed. This video asks what a team does about it, using a fictional junior developer, Pat, who ships ten thousand lines on Tuesday and watches the servers burn on Friday at 3 a.m.
It walks Pat’s Scrum team through the AI-native playbook Anthropic published in August 2026: a problem written as INTENT.md and reviewed by the Product Owner, a SPEC.md with the organization’s rules applied as it is written, and a PLAN.md that Pat challenges before any code exists. Rules live in CLAUDE.md, tests come first, and plain scripts (hooks) stop the AI from editing its own tests or passing the production gate. Reviews run against a written REVIEW.md, owned by another Developer on Pat’s Scrum Team, and the agent that wrote the code can’t approve it.
My first reaction was “waterfall, in markdown.” I helped write The Enterprise Unified Process in 2005, so I know that staircase. Read again, this is a loop that turns in hours, with the same small team all the way around. The documents were never the problem. The handoffs and the waiting were.
That is the Scrum Definition of Done enforced while the work happens, not argued about at Sprint Review. And the chicken and pig still apply: a model doesn’t get fired when customer data leaks. Pat is the conductor, and accountability stays human. The suggested step is small: start with one file this Sprint, your CLAUDE.md or your first INTENT.md, and inspect and adapt it with your whole team, humans and AI together.
Video transcript
Lightly edited from the video’s captions: timestamps removed, punctuation added, Scrum terms linked to the Guide at first mention.
Pat ships 10,000 lines. Friday, 3 a.m., servers on fire
On Tuesday, Pat ships ten thousand lines of code. On Friday at 3 a.m., the servers are on fire, and Pat has no idea why.
Pat isn’t real. But you’ve met them. Maybe you’ve been them. Junior developer, fintech startup, and their AI assistant just made them three, four, five times faster.
Tuesday, Pat’s thinking: “I’m a coding god.” Friday, staring at a memory leak in code they never actually read: “I didn’t write this. I just hit Tab.”
Here’s the thing. Pat is not the villain. In my last video I called this the 1999 trap. AI blew the top of the funnel wide open. But the bottom of the funnel didn’t change. Code review. QA. The security board that meets on Thursdays. Release approvals. All still running at human speed.
So the code piles up in the middle. Nobody can inspect it, so nobody can adapt. The Definition of Done quietly dies. And leadership says: “Buy more licenses. Spend more tokens, max them out. Go faster.”
Anthropic’s AI-Native SDLC Playbook: code is no longer the bottleneck
On August 21st, 2026, Anthropic published a playbook that says it in one line: code is no longer the bottleneck.
So, now what? Let’s walk Pat’s Scrum team through it.
INTENT.md, SPEC.md, PLAN.md: Plan, Design and Build
The old way started with a game of telephone. The stakeholder tells an analyst, who tells the Product Owner, who tells an architect, who tells Pat. By the time Pat types anything, the idea has changed hands four times.
In the playbook, the person with the problem says it in their own words, working with Claude. “Customers keep giving up at checkout. Why?” That becomes a file called INTENT.md: the problem, the outcome, the users, the constraints, the open questions. The Product Owner reviews it, corrects it, and commits it. That’s a new Product Backlog item, fed in right from the source.
Next, Claude turns INTENT.md into SPEC.md, with your organization’s rules loaded as skills: brand, security, compliance. Policy gets applied while the spec is written, not weeks later in a review meeting. The Product Owner reviews the spec. Doesn’t write it. And when Claude hits a conflict, it doesn’t decide. It flags it, and a policy owner resolves it. In the playbook’s words: “A human team mate always makes this call.”
Now, Sprint Planning. Pat doesn’t open a blank file. They run Claude in plan mode, where it can read everything and change nothing. It writes PLAN.md: which files change, in what order, and which tests prove it works. Pat pushes back: “If you change that schema in step two, what breaks?” The plan improves. Only when Pat accepts it does any code get written. Nothing is implemented without an accepted plan.
CLAUDE.md, git worktrees and the conductor
And the rules that only live in your senior developers’ heads? At Pat’s company, money is never a floating-point number. It’s always BigDecimal. That rule goes into a file called CLAUDE.md, which the agent reads before it starts. Keep it under a page. When Claude makes the same mistake twice, add the correction.
Now Pat can run two or three sessions side by side, each in its own git worktree. They stop being a soloist and become a conductor.
Hang on to that. INTENT.md. SPEC.md. PLAN.md. A document, a review, a handoff to the next stage. Wait a minute. I’ve seen this movie before. I actually helped write it. Confession time.
My confession: The Enterprise Unified Process (2005)
In 2005, Scott Ambler and I published The Enterprise Unified Process book. It took the Rational Unified Process and stretched it across the whole enterprise, where we added five new disciplines and two new phases. Phases. Gates. Documents handed from role to role. Inception, Elaboration, Construction, Transition, and the two we added: Production and Retirement. On paper, it was beautiful. In real life, it still looked like a staircase. Work fell down it one step at a time.
Some context on why this matters to me. I started writing code at EDS in 1991. In the late 90s I lived through two startups: one IPO, one dot-bomb. In January 2004, Ken Schwaber trained me as CSM number 72. Scrum was supposed to be the way off that staircase.
But over the last 20 years as a Certified Scrum Trainer with the Scrum Alliance, I’ve watched phase-gate thinking sneak right into Scrum anyway. Sprints became mini-waterfalls. The Daily Scrum became a status report. The handoffs just got new names. Death by a thousand cuts.
So when I first read this playbook by Anthropic, my first thought was: “Oh crap. Waterfall, in markdown.” Then I read it again. It’s not a staircase.
Not a staircase. A loop.
It’s a loop. Each committed file kicks off the next stage, and the loop turns in hours, not months. Same small team, all the way around. Nothing gets thrown over a wall. And the chain of commits is the audit trail, so you don’t need a committee to prove what happened.
Here’s what I wish I’d understood, or better communicated, back in 2005. The documents were never the problem. The handoffs were. The waiting was. We’ve witnessed zero improvements in cycle times by ignoring the core Scrum theory, values, and the purpose of implementing Scrum in the first place.
Can AI grade its own exam? Tests, hooks and evals
Now the part that keeps people up at night. If the AI writes the code and the tests, isn’t that a student grading their own exam? Here’s how the Anthropic playbook handles it.
Pat writes the failing test first, and commits it. Then a hook, a plain script with no AI in it, blocks Claude from editing the test files during the fix. Claude runs the tests, reads the failure, fixes the code, and runs them again until they pass. The student can’t touch the answer key.
Your CLAUDE.md, your skills and your hooks are now part of how software gets built, so you test them too. Collect twenty to fifty real tasks your team has already done, and rerun them whenever any of that changes. Every production incident becomes a new one.
Remember the security board that meets on Thursdays?
REVIEW.md: the agent that wrote the code can’t approve it
Now every pull request gets reviewed against a written policy, REVIEW.md, owned by Pat’s tech lead, another Developer on their Scrum Team. Claude checks for bugs, for security, and against the spec and the plan. A reviewer wants a change? Tag Claude in the comment and it pushes the fix.
But here’s the line in that playbook that matters most to me: “the agent that wrote the code has no way to approve it.” A human approves.
And production? The agent can act right up to the production gate. It cannot pass it. It tries to read the secrets: blocked. It tries to deploy without the release manager’s authorization: blocked. No prompt talks its way past a hook.
That’s your Scrum Definition of Done, enforced while the work happens, not argued about at Sprint Review. If it doesn’t meet the Definition of Done, it doesn’t exist.
3 a.m. again: Western Electric rules and rollback
Remember Friday, 3 a.m.? Let’s run it again. A new deploy goes out, and the error rate starts climbing. A plain statistical script compares it to the last thirty days using Western Electric rules, an old factory quality-control idea. No AI deciding whether it’s real. Just math.
One sigma out: it logs it. Two sigma: Claude reads the logs, read-only, and diagnoses. Three sigma: Claude can open a fix, or trigger the rollback your team already rehearsed. It posts all of it in the incident channel in Slack. Pat’s still looking for their slippers.
When the fire’s out, Claude writes a new INTENT.md, and the loop starts all over again. Pat reads it over coffee. Then the team takes it into the Sprint Retrospective and asks the real question: why do we keep driving down this road?
The Chicken and the Pig: who is accountable?
I created the original Scrum chicken and pig cartoons. The chicken and the pig want to open a restaurant called Ham and Eggs. The chicken is involved. The pig is committed. Right now a lot of leaders are trying to make the AI the pig.
It can’t be. A model doesn’t get fired when customer data leaks. It doesn’t lose sleep at 3 a.m. It just predicts the next token.
Pat is the conductor now. And when the orchestra plays out of tune, nobody blames the violins. As the Anthropic playbook puts it: “The loop keeps running. Human judgement stays above it.”
This playbook came out from Anthropic in August of 2026. I expect it to keep evolving, so treat it like anything else when implementing Scrum: try it, inspect it, adapt it, with your whole team, humans and AI together. Start with one file this Sprint. Your CLAUDE.md, or your first INTENT.md.
Code got cheap. Accountability didn’t.
AI didn’t make the old process obsolete. It made it impossible to hide. Code got cheap. Accountability didn’t.
Your next step
If this helped, here’s your next step. More than 2,500 leaders receive my emails every weekend. Join them at michaelvizdos.com/focus. You’ll get my cartoons and what I’m learning about implementing Scrum, with humans and AI on the same team. That’s michaelvizdos.com/focus.
Next: Part 3, Why AI Is Breaking Your Definition of Done asks who decides Done and what to add to your Definition of Done for AI-written code.
Get the free Study Kit
Full audio book + printable PDF. Includes the Saturday morning cartoons.
Get the Free Study Kit