What the Claude Code Team Gets Right About Verification, and How to Apply It
The Claude Code team says about 90% of its code is written and reviewed by Claude. Its verification rules are the best public guide to making that safe. Here is how they apply to a team without its tooling.
Yunhao Jiao9 分で読めます

On November 16, Addy Osmani published How the Claude Code team thinks about verification, the most concrete public account yet of how a team that has Claude write and review most of its code keeps that code working. If you build with coding agents, read it. Its core claim is simple: “Verification loops are the building block that lets you delegate more work to Claude.”
It also set off a long Hacker News thread, and the sharpest objections there weren’t about the ideas. They were about cost, and about something harder: a verification loop can be thorough and still check the wrong thing. Below are the five rules from the post we’d adopt first, what each one asks of a team that doesn’t have Anthropic’s tooling, and at the end, where TestSprite fits.
1. Run the app, end to end
“Running the app end to end matters more than tests,” the post says. Before committing, the team’s agents drive the real app: a browser for web, simulators for mobile, a local service for the backend. If you can invest in only one kind of test, the post recommends end-to-end tests of real user flows, like cart, checkout and confirmation. A unit test can pass while the feature is broken; a test that walks the whole flow is much harder to fool.
What it asks of you: a harness that boots the app, signs in, drives it and records what happened, and a list of the flows that matter. The Claude Code team built theirs as a verify skill next to the code.
2. A change can’t modify the check that judges it
The line worth taping to your monitor: “If a change can modify the check that judges it, the check is broken.” The team reads its review rules from the base branch, never from the pull request, and ties each review to a commit, because “a passing review on an out-of-date commit means nothing.”
The same rule applies one level up, to what a test expects. When the agent that wrote the code also writes the tests, the tests take their right answer from the code. Commenters on HN described exactly this: green tests that agreed with the bugs. What it asks of you: keep expectations somewhere the change can’t reach, and decide who is allowed to change them.
3. People decide what “done” means
On the Claude Code team, code owners write and refine their own checks, and the post closes on the human job: moving “from reading every diff to defining what ‘done’ looks like and reviewing the evidence.”
That definition of done is the hardest part to write, and an HN commenter put the problem bluntly: if half of an agent’s first implementations head in the wrong direction, how do customers stay happy when nobody reads the code? A loop that checks the code against itself won’t catch a wrong direction. A reference written from intent can, as long as the reference is right, which is why a person should approve it. What it asks of you: write down what the product should do, in words a reviewer can check a run against. Our guide to writing a PRD for AI coding agents covers what to put in it.
4. Failures decide what needs a person
Nobody can read every change, so the team uses failures to decide where people look. If a check still fails after three rounds of fixes, Claude stops and brings in a human. Flaky tests count as bugs in the loop: “Claude can’t skip them, add sleeps or retry until they pass.”
What it asks of you: failures a person can act on quickly. A red mark that might be a bug, a stale test or a dead staging server costs the reviewer the same twenty minutes either way. A failure that arrives with its evidence, and a first read on which of the three it is, tells them where to start.
5. Gate the merge, and start in observe mode
The team stamps each commit with how it was verified and can block commits that skipped /verify or /code-review. A new gate starts in observe mode, which logs what it would have blocked, before it enforces anything. That’s the right way to introduce any gate: earn the team’s trust, then make it required.
The cost question
The top comment on HN called some of these practices very expensive next to deterministic tools like Playwright, which cost almost nothing to run in CI. That’s true of running them. The expensive part of a Playwright suite has always been writing it and keeping it current, and at agent speed the interface changes every day. The real trade is between a model re-deriving checks on every commit, which costs tokens, and a suite someone has to maintain, which costs people.
Where TestSprite fits
All of this can be built in-house, and the Claude Code team shows how far that goes. If you’d rather not build the outer layer yourself, that’s the part TestSprite covers. It doesn’t replace your coding agent’s /verify. It checks everything else the app should still do, on every pull request.
You describe what your product should do, or hand it a PRD or a ticket, and it drafts a test plan with each expected result in plain language; your team approves it, and an expectation changes only when someone approves the change. It drives your frontend in real browsers, signs itself in, tests backend flows across several requests, and reports a status check you can watch first and require later. Each failure comes with a replay, the failing step and expected versus actual, and a first read on whether it’s a real bug, a test problem or the environment. The agent writes and maintains the suite, and every test can be exported as Playwright code (Python), so you’re never locked in.

Here is what’s new in TestSprite 4.0, including a merge that two green checks missed.