How the Claude Code team verifies code when Claude writes 90% of it
Chanwoo Song 6 min read

On November 16 (US time), Anthropic's Claude Code team published how it verifies its own work. The post, written by Addy Osmani on the claude.dev blog, opens with a striking number: about 90% of the Claude Code team's code is written and reviewed by Claude.
So the team's question is what to trust when no person can read every change. The post's answer is verification loops. Only when agents can prove their work with evidence can you run dozens or hundreds of Claudes at once instead of one or two. In internal testing, having a separate grader check Claude's output against a rubric improved task success by up to 10 points over a standard prompting loop.
The post drew more than 1.51 million views and 13,000 likes from the @ClaudeDevs account on X, and 254 points and 197 comments on Hacker News.
Verification starts with running the app, not with tests.
The first thing the post stresses is actually running the changed app. Just as you would not ship an iOS change without trying it in a simulator, Claude should not either. Web changes go through the Claude Chrome extension, mobile through an iOS or Android MCP, desktop through computer use, and backend work by running the service locally.
The method is simple. How to boot and drive the app is written down as a skill called verify in the repository's .claude/skills/ folder, and Claude uses it before committing. The team says it puts real effort into making that skill fast and reliable, and that this is how nearly all changes at Anthropic are tested.
The post names three kinds of tests. If you pick only one, pick end-to-end tests. They follow real user flows such as adding an item to a cart, checking out and reaching a confirmation page, so the feature either works or it does not, which makes them hard to fool. Unit tests can pass while the feature is broken.

The other two are property tests and differential tests. A property test states something that must never break, such as "encode then decode returns the original" or "a balance can never go negative," and a library generates thousands of inputs to try to break it. Its edge cases are not created with the same bias as the agent that wrote the code. A differential test feeds the same inputs to the old and new systems and treats any difference as a bug, which is especially useful for large migrations.
After three failed fix attempts, Claude stops and calls a human.
Since nobody can read every change, failed checks decide where people look. Claude runs the checks and fixes what fails; if a check is still failing after three rounds, it stops and brings in a human. The code owners write the checks themselves, and a check that pulls in a reviewer has to say why, so the reviewer does not have to work it out from the diff.
Past incidents live on as a checklist. The reliability checklist has 39 items, each with a trigger that can be read from a diff, a check, and the incidents or PRs behind it. For example, when session storage changes, the item asks whether --resume can still load old transcripts. Claude checks only the items whose trigger matches the diff, usually 3 to 10, so nobody has to memorize past outages.

A change cannot modify the checks that judge it.
This is the principle worth noting most. If a change can modify the check that judges it, the post says, the check is broken. So REVIEW.md, which holds the review rules, is read from the base branch, never from the version inside the pull request. It blocks, by design, an agent passing a test by editing the test.
The team also prefers running one reviewer for several rounds over stacking more reviewers. Tuning the primary reviewer beats adding a second, more expensive one, and each round builds on earlier rounds and past failures instead of re-checking from scratch. If someone pushes during a review, the result is discarded, since a passing review on an out-of-date commit means nothing.
Commits carry safeguards as well. Each commit is stamped with how it was verified, and "none" is one of the values, so unverified commits can be queried. A commit gate can block a commit if the session never ran /code-review or /verify. It has off, observe and enforce modes, and a new gate starts in observe mode, logging what it would have blocked so false positives can be reviewed. If commits are blocked twice in one session, the third is allowed through so Claude does not get stuck; Claude Code isn't perfect, the post notes.
Missed bugs become rules, and rules get pruned.
Reviewers are graded too, using changes reverted after merging, changes a maintainer rejected before merging, and a size-matched set of changes that stayed clean. Missed bugs become rules in two ways. Patterns are extracted from human review comments and reverted PRs, but a candidate must appear in at least two PRs and be identifiable from a diff. Three agents then try to disprove it, and a human approves it in a PR.
Flaky tests have a rule as well. Claude cannot skip them, add sleeps or retry until they pass; if it cannot find the root cause, it deletes the test and writes down why. Test suites, verification steps and .md files only grow if left alone, so the team tidies them up on a routine.
In September, in a post on code review in the AI era (in Korean), I suggested checking results directly with Playwright and adding gates the AI cannot fool. What the Claude Code team actually runs extends that idea. The difference is that it has hardened it into skills, checklists and commit gates that work without anyone having to remember them.
The post closes by saying this shifts the human job from reading every diff to defining what "done" looks like and reviewing the evidence. As handing tests and verification to agents gets cheaper, a team's strength will likely come down to how well it builds and maintains its verification tools.
https://claude.dev/blog/how-the-claude-code-team-thinks-about-verification/