Claude Automates Software Safety Proofs to Slash Verification Costs

Anthropic’s Claude model has successfully generated approximately 180 million lines of mathematical proof code to verify the correctness of existing software libraries, a development that significantly lowers the barrier to formal verification. In a collaboration with partner Theorem, the AI produced these proofs for 123 open-source libraries within a matter of weeks, a task that has historically required vast amounts of human expertise and time. This achievement marks a pivotal shift in how software safety is established, moving from a manual, labor-intensive process to an automated one.

The economic and logistical hurdles of formal verification have long prevented its widespread adoption. Traditionally, proving that code runs without errors under all possible conditions is prohibitively expensive; for instance, a team of specialists required 20 person-years to verify the seL4 operating system kernel. Consequently, this rigorous method was largely reserved for high-stakes environments such as Airbus avionics, where failure is not an option. By automating the proof generation, Anthropic and Theorem have begun to dismantle the cost structures that kept formal verification out of reach for most software projects.

The methodology employed by Claude did not involve writing new application code from scratch. Instead, the model focused on verifying existing software by translating crash tests into mathematical problems and analyzing compiled machine code. This process resulted in extensive proofs that were automatically checked by an independent verification program called Rocq. According to Anthropic, the system operates with minimal human intervention, a capability the researchers describe as "fully autonomous" proof generation. However, it is important to note that the underlying tools and formal foundations were developed by human engineers at Theorem.

A significant benefit of this automated approach is its ability to uncover latent defects that conventional testing methods often miss. While generating the proofs, Claude identified hundreds of bugs and was permitted to fix them autonomously. Many of these errors would have remained undetected because they only manifest under specific, unusual conditions, such as processing unusually large input files or specific sequences of memory access. The AI’s capacity to explore these edge cases far exceeds the scope of standard test suites.

The efficiency of the system was highlighted during the verification of a widely used PDF reader, where the team discovered as many security vulnerabilities in a single week as are typically reported for that software over an entire year. In another instance, Claude detected a logical error that had persisted undetected for more than a decade. Anthropic notes that even when a complete proof fails, the attempt often surfaces genuine bugs, making the process valuable even in cases where the final verification is not achieved.

Despite the breakthrough, Anthropic cautions that "formally verified" does not equate to "error-free." The mathematical proofs hold only under strict constraints, including a specific processor architecture, single-threaded program execution, and input sizes limited to 64 MB. In practical deployment, these libraries often run on diverse hardware and configurations, meaning the verification provides a strong guarantee only within those defined parameters.

The computational cost of this process remains substantial, with individual proofs requiring hundreds of millions of tokens to generate. While Anthropic has not disclosed the total project costs, the efficiency gains are evident in the model's performance. Newer versions of the model, such as Opus 5.5, are solving half of the proofs using approximately 40 percent fewer tokens than the previous Opus 5 version, indicating a trajectory toward greater cost-effectiveness.

This project strengthens the argument for broader software automation by shifting the focus from whether AI can program to whether it can prove its code is safe. If AI can guarantee correctness under defined conditions, developers can place greater trust in AI-generated software, reducing the time spent on manual review. This efficiency could lower costs across the entire coding lifecycle, not just in the verification phase.

Looking ahead, Anthropic expects formal verification with AI to become as routine as standard testing. Theorem’s roadmap already targets critical infrastructure components such as glibc, OpenSSL, and cURL. If these targets are met, the implications for software reliability and development speed could extend well beyond current coding tools, fundamentally altering how secure software is built and maintained.

For readers in the Southwest and beyond, this advancement suggests a future where software stability is mathematically assured rather than statistically tested. As AI models become more efficient at proving their own correctness, the industry may see a rapid adoption of these methods, potentially redefining the standards for software quality in critical applications.