0:00Claude Code now writes ~90% of its own code, and the pace is accelerating. Between June and September, merged PRs more than doubled, while code that got reverted or went wrong dropped 40%. Rob Shocks pieces together what Anthropic is doing — from the Claude Code team's published code-review process, plus the in-house system that's quietly replacing Git. He flags up front that Anthropic is both a useful signal and a company selling inference and a vision, so he separates marketing from the practical gains other companies can actually copy.
The bold goal
3:11The core reframe: "did a human review this code?" was always a proxy for the real question — "what could go wrong with this change, and which check (automated or human) is the right one to catch it?" Review also moved in time: from a single gate just before merge, to constant checks from the first prompt to the merge, "more like spellcheck as you write." 3:40The target Anthropic set: most PRs should merge with at most one human in the loop — and that human can be the author. The new metrics are human approvals per PR, human comments, and time waiting on a person — potentially supplementing or replacing DORA metrics. The guardrail is revert and incident rates: if those rise, they haven't saved human time, only moved it.
Six layers, rollback under
4:40The system is six layers of checks with rollback underneath — few problems get through all six, and rollback catches the rest.
5:04Layer 1 — verification before anyone looks. Most review happens before the PR exists. Claude gets something it can run (tests, build, screenshots, end-to-end) and has to show the output rather than say "it's done." A subagent then reviews the diff in a fresh context. Boris Cherny, Claude Code's creator, estimates verification makes the final result 2–3× better. Repeated findings get fixed at the source: CLAUDE.md (the project's stack/conventions/goals) and REVIEW.md (code owners writing what matters in their code — including a cap on nitpicks, since nitpicking often flags pre-existing code pulled into the PR that isn't part of the change).
6:26Layer 2 — AI review on every PR, before a person looks. It reads the diff against the whole repo and the PR's stated intent. Several agents hunt for bugs in parallel; a separate group votes on each finding; the reviewer posts it only if enough agree it's real. 6:53Layer 3 — a separate security review (a PR can't merge while any bug-review or security finding is open). 7:06Layer 4 — the boring checks that still block: lint, type checks, tests on every platform, and a build. The PR template asks how it was tested and how to undo it.
8:19Layer 5 — human approval, scaled by risk. Low-risk (docs, copy, additive changes behind a flag) needs no human once automated + security checks are green; ordinary product work needs one person; high-risk code needs two. 10:07Layer 6 — the merge queue: re-runs every check against main with the change applied, so two PRs that pass separately can't combine into a broken main. New behavior ships behind a flag — internal team first, then a latest channel (~1,000+ people), then stable.
The five approval rules
8:56Rob extracts five rules from the human-approval layer:
- The change sets the tier, not the author. A classifier reads the change and picks the tier; a second checks whether it needs a person anyway (any CI workflow change always does).
- Only trusted authors (mostly the owning team) get the lighter paths.
- An agent's approval never counts as a person's. Automated review can clear a low-risk change but can't fill a human slot.
- Whoever prompted the change is on the hook. On an agent-written PR, the person directing it counts as a reviewer — if the agent does a bad job, it's your problem.
- An approval covers one specific commit. A new agent push resets it.
10:54The backbone is fast detection + fast rollback — flags switch off without a deploy, weekly on-call, and incident reviews ask which layer should have caught it. The admitted gap: no circuit breaker yet — if revert rates spike, nothing automatically tightens approval. Anthropic's stance: slowing down lowers your error rate mostly because you're doing less of everything; better to get faster at noticing and fixing.
The 50-round trap
11:57The cautionary story: one Claude Code CLI PR went through more than 50 rounds of AI review and fixes overnight before its author stopped it — nobody was watching, so the loop spun. git blame showed ~59% of what kept getting flagged was code that had been there since the first pass: the reviewer wasn't finding new bugs, just a few more old ones each round. A person waves off a nitpick in seconds; an agent fixes it, spawning another commit and round. 13:20Anthropic's fixes: a round cap (after three, ask the author to step back), diff-only re-review on later passes, flag the class of bug (not just the line), and never repeat a finding. 13:46And the eval loop: past incidents become a benchmark — real PRs that caused incidents, confirmed by engineers, run against the reviewer every day to check whether it's improving or getting worse.
Where the product fits
14:04Claude Code's Code Review product just went generally available (enterprise first). It's the public version of layer 2: agents search the diff in parallel, a verification step filters false positives, findings are ranked by severity and posted as inline comments + a check run. Anthropic claims reviews are now ~3× faster (from ~20 minutes to ~6–10). You pick Quick / Standard / Deep per repository, deeper costs more. 14:46One thing that surprises people: the product never approves or blocks a PR — matching the internal rule that an agent's approval never counts as a person's. Locally it gives a lighter /code-review pass; /security-review covers the security layer. Rob's advice: study how they do it, then build your own version tuned to how your company works.
Scion: replacing Git
15:15The last piece: Anthropic replaced Git on its monorepo with an in-house system called Scion, plus a review tool. The trigger was AI-scale volume: the main branch has almost 100 GB of history, and CI checks it out ~25 million times a day. A seven-person team built it and finished the migration in ~5 months, reporting a footprint 200× smaller than the old Git mirroring. Nobody outside Anthropic has tested it yet — it's the extreme edge of the same "agents changed the volume" problem, not a tool your team will adopt this week.
What you can copy
15:56Rob's shortlist for a normal team today: give your agent checks it can run; add a REVIEW.md; put an AI reviewer on one repo and tune it for a couple of weeks; set risk tiers by the change, not the author (how big is the blast radius?); never let an agent's approval replace a human's; and measure your revert rate. The open question he poses to practicing developers: would you let a low-risk PR merge with zero human approval if every check were green?
Claims checked
The underlying process is Anthropic's own published article — "How the Claude Code team does code review" (Oct 15, 2026). The six layers, the 50-round PR, 59% pre-existing code, and the convergence fixes all trace to it. (This site's own deep dive on it is here.)
Scion is real — "Redesigning source control at Anthropic" (Oct 13, 2026): ~100 GB history, ~25M CI checkouts/day, 7-person team, 5-month migration. (The transcript renders it "Seon"; the correct name is Scion.)
Code Review is GA — announcement, plus the docs. The "~3× faster / 20→6–10 min" figure is Anthropic's claim, relayed via the video.
OpenRouter "Armor" is a paid sponsor segment (mid-video): a beta guardrail that checks agent tool calls against policy using TypeSafe's Jev model, claimed to "beat Claude Code's autoclassifier at a fraction of the cost." Described for context; no sponsor link reproduced. The "Antique" review-tool name is the speaker's relay and is not confirmed in Anthropic's source-control article.