Automated Assurance: Claude Generates 180 Million Lines of Proof for Open-Source Code

For developers and users relying on open-source software, the landscape of code safety is shifting from manual inspection to automated mathematical certainty. While most software bugs are discovered through standard testing, a new approach led by Anthropic suggests that artificial intelligence can now independently prove code correctness, potentially catching errors that have eluded human reviewers for years. This development implies that the trustworthiness of AI-generated or AI-verified software may soon be established through rigorous proof rather than just successful execution.

The scale of this recent effort is significant. Working with partner Theorem, Anthropic’s Frontier Red Team utilized the Claude model to generate approximately 180 million lines of mathematical proof code over a period of just a few weeks. This volume of verification work was applied to 123 open-source libraries sourced from Google’s OSS-Fuzz security project. The process did not involve writing new application code but rather translating existing crash tests into mathematical problems, analyzing compiled machine code, and producing extensive formal proofs to validate the logic.

Traditionally, formal verification has been a resource-intensive process reserved for critical systems where failure is not an option. For context, a team of specialists required 20 person-years to formally verify the small operating system kernel seL4. Due to this cost, the method was typically limited to extreme cases such as Airbus avionics software. By allowing Claude to handle the proof generation, Anthropic has dramatically compressed the timeline, suggesting that the barrier to entry for this level of assurance may be lowering for a broader range of software applications.

The methodology relies on an independent verification program called Rocq to automatically check the proofs produced by Claude. According to Anthropic, the process requires almost no human reviewers, a state the researchers describe as “fully autonomous” proof generation. However, it is important to note that while the execution is automated, the underlying tools and formal foundations were developed by humans at Theorem. This distinction highlights that the autonomy lies in the application of the verification process, not necessarily in the creation of the verification framework itself.

One of the most striking outcomes of this project is the discovery of hundreds of bugs that conventional testing had missed. Many of these defects only manifest under very specific conditions, such as unusually large input files or particular sequences of data access, making them difficult to detect through standard unit or integration testing. In one notable instance, while verifying a widely used PDF reader, the team identified as many security bugs in a single week as are typically reported for that software in an entire year. In another application, Claude uncovered a logical error that had remained undetected for over a decade.

Despite these successes, the definition of “formally verified” carries specific constraints. Anthropic acknowledges that verification does not equate to being error-free in all contexts. The proofs hold only under strict conditions, including a specific processor architecture, single-threaded programs, and inputs smaller than 64 MB. In practical deployment, these libraries often run on diverse hardware and in multi-threaded environments, meaning the mathematical certainty is conditional rather than absolute. Furthermore, the compute cost remains steep, with individual proofs consuming hundreds of millions of tokens, though Anthropic has not disclosed the total project costs.

The economic implications of this technology extend beyond the verification process itself. If AI can reliably verify its own code, developers may spend less time on manual review, reducing costs across the entire coding lifecycle. A smaller test run indicated that proofs are reusable, and newer models are showing improved efficiency; Opus 5.5, for example, solved half the proofs with approximately 40 percent fewer tokens than its predecessor, Opus 5. This trend suggests that as models become more efficient, the cost of formal verification may decrease further, making it a more viable option for mainstream software development.

The broader stakes involve a shift in how the industry views software automation. The central question is moving from whether AI can program to whether AI can guarantee the safety of the code it writes. Anthropic expects that formal verification with AI will soon become as routine as standard testing. Theorem’s roadmap already targets critical infrastructure components such as glibc, OpenSSL, and cURL, indicating that this technology is poised to move from experimental projects to foundational system software, fundamentally altering how developers ensure reliability in an increasingly automated coding environment.