Claude Generates 180 Million Lines of Proof to Validate Open-Source Security

Anthropic has successfully deployed its Claude model to autonomously generate mathematical proofs for existing software, a breakthrough that fundamentally alters the cost and speed of verifying code correctness. By leveraging the model to translate standard crash tests into rigorous mathematical problems, the company has demonstrated that artificial intelligence can now perform the labor-intensive work of formal verification at a scale previously reserved for high-stakes industries like aviation.

The scope of this recent effort is substantial. In a matter of weeks, Claude produced approximately 180 million lines of proof code, drawing on test programs from 123 open-source libraries within Google’s OSS-Fuzz security project. This output is particularly significant given the historical cost of such work; for example, a team of specialists required 20 person-years to formally verify the seL4 operating system kernel. By automating this process, Anthropic has compressed a timeline that typically spans years into a period of mere weeks, while simultaneously uncovering hundreds of bugs that conventional testing had failed to detect.

The collaboration was led by Anthropic’s Frontier Red Team in partnership with Theorem. Rather than writing new code from scratch, Claude analyzed compiled machine code and generated extensive proofs that were then automatically checked by an independent verification program named Rocq. The researchers describe the process as "fully autonomous," noting that it required minimal human review, although the underlying formal foundations and tools were originally built by human engineers at Theorem.

The practical value of this automation was evident in the number of vulnerabilities discovered. Claude identified hundreds of bugs, many of which were hidden behind specific conditions such as unusually large input files or rare sequences of data access. In one notable instance, the team found as many security bugs in a widely used PDF reader in a single week as are typically reported for that software over an entire year. In another case, the model caught a logical error that had remained undetected for more than a decade. Even when a complete proof was not achieved, the attempt itself surfaced critical errors.

Despite these successes, the approach has defined limits. Anthropic clarifies that "formally verified" does not equate to "error-free." The proofs hold only under strict conditions, including specific processor architectures, single-threaded execution, and inputs under 64 MB. Additionally, the compute requirements are significant, with individual proofs consuming up to hundreds of millions of tokens. However, efficiency is improving; a smaller test run showed that newer models like Opus 5.5 can solve half the proofs with roughly 40 percent fewer tokens than the previous version.

The long-term stakes involve a shift in how developers trust AI-generated software. If AI can write code and prove its safety under defined conditions, the industry can move beyond the question of whether AI can program to whether it can guarantee its own correctness. This capability could make formal verification as routine as standard testing, with Theorem’s roadmap already targeting critical infrastructure libraries such as glibc, OpenSSL, and cURL. For New England’s tech ecosystem, this suggests a future where software reliability is mathematically assured rather than just statistically probable.

This development marks a pivotal moment for software automation. By reducing the cost of verification, companies can spend less time on manual review and more on innovation. The ability to reuse proofs and the increasing efficiency of newer models indicate that this is not a one-off experiment but the beginning of a new standard for code safety.