Back to Articles

Building Autonomous Code Systems: Claude Code Verification Tips

November 18, 2026485

How to build a self-reliant system? Insights from the Claude Code team on code verification

When working with AI agents for coding, the biggest challenge is not just the ability to generate solutions, but the ability to ensure they actually work. The Claude Code team at Anthropic reached a far-reaching conclusion: about 90% of their code is written and tested by Claude itself. To reach such a level of autonomy, they developed a rigorous verification methodology that changes the way we should look at agent-based software development.

Why is verification the key to success?

The most common mistake is to settle for basic unit tests. At Anthropic, they emphasize that for an agent to be truly effective, it must have "eyes and hands" on the running system. This means not just running code, but performing end-to-end (E2E) processes that prove the feature works exactly as an end-user would experience it.

The Claude Code team's approach focuses on three critical types of tests:

  • •E2E Tests: These are the most important tests. They describe real user processes (such as adding a product to a cart or a login process). They are hard to fake and provide an unambiguous indication of whether the system is functional or not.
  • •Property Tests: Instead of testing only what we thought might go wrong, we use dedicated libraries to generate thousands of inputs that try to "break" the code. This is critical for finding edge cases that human programmers tend to miss.
  • •Differential Tests: An especially powerful tool for migrations. You run the old and new systems in parallel with the same inputs and compare the results. If there is a difference – there is a bug.

The danger of flaky tests

One of the most important lessons from the article is the warning against flaky tests. If a test fails randomly, the agent will learn to "cheat" – it will run it again and again until it passes, instead of fixing the actual problem in the code. This is a destructive behavioral pattern that harms the reliability of the entire system. The team's solution is to invest in reliable and fast tests, and define "failure thresholds" – if a test fails three times in a row, the agent stops and requests human intervention.

How to implement this in practice?

To stop testing everything manually, you should adopt Anthropic's approach:

  1. •Creating a Verify Skill: Define a script or command in your project folder called
    verify
    . The agent should know how to run it before every commit. This is your smoke test.
  2. •Context-based Review: Do not try to add more and more human reviewers. Use secondary agents that review the diff against the original task requirements, and rank bugs by severity.
  3. •Risk Documentation: Use
    REVIEW.md
    files that guide the agent (and the human) on what to look out for in this specific project, instead of relying on memory.

Summary and conclusions

The transition to agent-based development requires us to shift from "code writers" to "quality managers." The more we invest in building a strong verification infrastructure – one that allows the agent to prove its work through real execution – the more responsibility we can transfer to the machine.

The bottom line is clear: Do not trust your agent with your eyes closed. Give it the tools to test itself, and set the boundaries that will prevent it from hiding glitches.

For further reading:

Thanks to Spotlight by Daniel Trabelsi by Daniel Trabelsi for sharing and inspiring this article.

Join the channel
#AI agents#Claude Code#software development#automated testing#code verification#Anthropic#E2E testing#flaky tests