AI Proofing: Anthropic and Theorem Automate Software Verification

Anthropic and its partner Theorem have demonstrated a significant advancement in software reliability by using the Claude model to mathematically verify existing code. This joint effort focuses on generating formal proofs of correctness for established software libraries rather than creating new applications from scratch. By automating the verification process, the teams aim to address a longstanding challenge in the industry, which is the high cost and complexity of proving that software runs without errors under all possible conditions.

The scale of this automated verification effort is substantial. In a matter of weeks, Claude produced approximately 180 million lines of mathematical proof code. These proofs were derived from test programs associated with 123 open-source libraries within Google's OSS-Fuzz security project. The process involves translating crash tests into mathematical problems, analyzing the compiled machine code, and generating extensive documentation that validates the software's behavior. An independent verification program named Rocq automatically checks these generated proofs, a workflow that Anthropic describes as requiring almost no human reviewers.

The human element remains crucial in the background. While the proof generation is termed fully autonomous, the underlying tools and formal foundations were developed by specialists at Theorem. The approach relies on a specific methodology where Claude does not write new application logic but instead validates existing code. This distinction is important because it allows the AI to focus on rigorous mathematical validation without the creative risks often associated with AI-generated code. The result is a system that can operate with minimal human intervention during the actual proofing phase.

One of the most notable outcomes of this project is the discovery of latent bugs. During the verification process, Claude identified hundreds of bugs that conventional testing methods had missed. Many of these issues only manifest under very specific conditions, such as unusually large input files or particular sequences of data access. In one specific case involving a widely used PDF reader, the team found as many security bugs in a single week as are typically reported for that software over an entire year. In another instance, the model caught a logical error that had remained undetected for more than ten years.

Despite these successes, the team acknowledges that formal verification has strict practical limits. The term formally verified does not imply that the software is completely error-free in every scenario. The proofs are only valid under specific conditions, including a particular processor architecture, single-threaded execution, and input files smaller than 64 MB. In real-world environments, these libraries often run on diverse hardware and configurations, which means the verification covers a defined subset of potential use cases rather than every possible situation.

The computational resources required for this process are significant. Individual proofs can consume hundreds of millions of tokens, though Anthropic has not disclosed the total cost of the project. However, the team notes that newer models are becoming more efficient. For example, Opus 5.5 solves half of the proofs using about 40 percent fewer tokens than its predecessor, Opus 5. This efficiency gain suggests that the cost of formal verification may decrease over time, making it more accessible for broader adoption in the software industry.

The project also demonstrates that proof attempts are valuable even when they do not result in a complete verification. Anthropic notes that even when a full proof fails, the process often surfaces real bugs. This capability could change how developers approach testing, shifting the focus from simply finding crashes to mathematically understanding why software behaves as it does. The reusability of these proofs was also observed in smaller test runs, indicating that the work done for one version of software can be leveraged for future updates.

Looking ahead, this development strengthens the argument for deeper software automation. If AI can both write code and prove its safety under defined conditions, the industry's focus may shift from whether AI can program to whether it can guarantee correctness. Anthropic expects that formal verification using AI will eventually become as routine as standard testing. Theorem's roadmap already includes targets for critical infrastructure components such as glibc, OpenSSL, and cURL, suggesting that this technology is moving beyond experimental phases toward practical, large-scale implementation.