- 1. AI Agent Verification Is What Lets You Delegate
- 2. Start With End-to-End Tests
- 3. Add Property and Differential Tests
- 4. Let the Agent Run the Thing
- 5. Keep the Checks Out of the Agent's Reach
- 6. Use a Separate Grader
- 7. Roll Out Gates Slowly and Know When to Stop
- A Starter Checklist for AI Agent Verification
- The Bigger Picture: Your Job Shifts to Defining Done
- Quick Questions, Answered
- Final Thoughts: Verification Before Scale
AI agent verification is the least glamorous part of working with coding agents, and it may be the most important. On November 16, 2026, the team behind Claude Code published a detailed look at how it checks agent output. The post drew hundreds of comments on Hacker News within days.
The core claim is simple. Without automatic checks, one person can supervise one or two agents. With them, dozens can run at once. Here are seven lessons from the post in plain language, plus a checklist you can copy. If agents are new to you, start with our guide to Agent Skills.
Key takeaways
- Anthropic says about 90% of the Claude Code team’s code is now written and reviewed by Claude. That figure is self-reported.
- AI agent verification, meaning checks the agent runs on its own work, is what makes parallel agents practical.
- If you can only invest in one kind of test, the team recommends end-to-end tests.
- A separate grader step raised task success by up to 10 points in the team’s internal tests.
~90%
Share of the Claude Code team’s code that is written and reviewed by Claude, according to the team’s own post. It is a self-reported figure.
1. AI Agent Verification Is What Lets You Delegate
Prompting gets an agent started. Checking is what lets you walk away. The post argues that the limit on agent work is not how fast the model writes. It is how fast a human can confirm the work is right.
Every check the agent can run for itself removes one reason to interrupt you. That is the whole case for AI agent verification in one line.
2. Start With End-to-End Tests
The team ranks test types, and end-to-end tests come first. These tests walk through a real user flow, such as adding an item to a cart, checking out, and reaching the confirmation page.
They are hard to fool, and they show exactly where things broke. Unit tests can all pass while the feature is still broken, which is why they are not first on the list.
3. Add Property and Differential Tests
Second come property tests. You write a statement that should never fail, then generate thousands of inputs to try to break it. An account balance can never go negative is a property. So is encoding then decoding returns the original. The post names fast-check for JavaScript, Hypothesis for Python, and proptest for Rust.
Third come differential tests, which suit large migrations. Run the old system and the new one on the same inputs, and treat any unapproved difference as a bug.

4. Let the Agent Run the Thing
Reading code is not the same as using the product. The team has Claude test the running app: a browser for web apps, device tools for mobile, a local service for back-end work.
It packages this as a verify skill stored in .claude/skills/ near the code it checks. The skill boots the app and drives it, and it has to be fast and reliable. The agent-browser CLI we covered recently fits this job.
5. Keep the Checks Out of the Agent’s Reach
A check that the agent can edit is not a check. The team’s review rules live in a REVIEW.md file that is read from the base branch, never from the pull request under review. Gating rules sit on a branch the change cannot modify.
The same idea applies to people. You do not grade your own exam.
6. Use a Separate Grader
For structured file generation, the team tested a second pass in which a separate grader scores the work against a rubric. In internal tests, that raised task success by up to 10 points over a standard prompting loop, with the biggest gains on the hardest problems.
The team’s reliability checklist has 39 items. Claude does not run all of them every time. It checks only the 3 to 10 items that apply to a given change.
7. Roll Out Gates Slowly and Know When to Stop
New gates go through three stages: off, observe, then enforce. In observe mode the gate only logs what it would have blocked, so false alarms can be fixed first.
There is also a limit on persistence. After three failed rounds of fixes, the agent escalates to a human. And flaky tests may not be skipped, padded with waits, or retried until they pass. If no one can find the cause, the test is deleted and the reason is written down.
A Starter Checklist for AI Agent Verification
- Write one end-to-end test for your most important user flow before adding more agents.
- Make the agent run tests, build, and linter before it opens a pull request.
- Store review rules where the change under review cannot edit them.
- Add a grader step with a short written rubric for repeatable tasks.
- Start every new gate in observe mode for a week.
- Set a three-round limit, then hand the problem to a person.
The Bigger Picture: Your Job Shifts to Defining Done
The post ends on a change in role. With solid AI agent verification, you stop reading every line. You define what finished looks like, then review the evidence. That is closer to how a good editor or manager works, and it echoes what we found in how people actually work with AI.
A caution is fair here. These are one team’s internal results, shared by the company that sells the tool. The practices are sound engineering either way, and most of them work with any agent, including the open models you can run yourself.
Quick Questions, Answered
Do I need all of this to use a coding agent? No. One reliable end-to-end test, and a rule that the agent must run it, gets you most of the benefit.
Does AI agent verification replace code review? It changes it. People review evidence and judgment calls, and machines handle the repeatable checks.
Is the 90% figure independent? No. It comes from Anthropic’s own post about its own team.
Final Thoughts: Verification Before Scale
It is tempting to add more agents when work feels slow. The Claude Code team’s advice is the reverse: build AI agent verification first, then scale. Pick one flow, write one end-to-end test, and make the agent prove its work before you read a single line.



