Anthropic’s AI System Generates 180 Million Lines of Proof Code to Verify Software Safety

Anthropic’s Claude model has begun generating vast quantities of mathematical proof code to verify the safety of existing software, marking a significant shift in how developers approach code correctness. By collaborating with partner Theorem, the company’s Frontier Red Team successfully produced approximately 180 million lines of proof code in a matter of weeks. This effort covered 123 open-source libraries from Google’s OSS-Fuzz security project, demonstrating that large language models can now handle complex verification tasks previously reserved for human specialists.

The initiative addresses a longstanding challenge in the software industry: proving that code runs without errors under all possible conditions has historically been prohibitively expensive. For context, a team of specialists required 20 person-years to formally verify the small operating system kernel seL4. Because of this cost, formal verification was typically limited to critical systems like Airbus avionics software. However, the recent project suggests that artificial intelligence can drastically reduce the time and labor required for such rigorous checks.

Rather than writing new applications from scratch, Claude focused on validating existing code. The model translated crash tests into mathematical problems and analyzed compiled machine code to generate extensive proofs. An independent verification program called Rocq then automatically checked these proofs. According to Anthropic, the process required minimal human review, leading researchers to describe the system as fully autonomous, even though the underlying tools and formal foundations were built by humans at Theorem.

The results included the discovery of hundreds of bugs that conventional testing had missed. These defects often remained hidden because they only appeared under very specific conditions, such as unusually large input files or particular sequences of data access. In one notable instance, the team found as many security bugs in a single week while verifying a widely used PDF reader as are typically reported for that software in an entire year. In another case, Claude identified a logical error that had gone undetected for over a decade.

The ability of the AI to fix these bugs itself further streamlined the process. Anthropic noted that even when a complete proof ultimately fails, the attempt still surfaces real issues. This suggests that formal verification attempts can serve as a powerful debugging tool, catching subtle errors that traditional testing methods might overlook. The system’s effectiveness was evident in its ability to handle complex scenarios that had eluded human testers for years.

Despite the promising results, Anthropic acknowledges that formal verification does not guarantee a program is completely error-free. The proofs hold only under strict conditions, including a specific processor architecture, single-threaded execution, and input sizes under 64 MB. In practice, these libraries often run on different hardware and in various configurations, meaning the verification provides a strong but limited assurance of safety.

The computational cost remains a significant factor. Individual proofs can require hundreds of millions of tokens to generate. While Anthropic did not report the total project costs, the efficiency gains from automation may offset these expenses. A smaller test run indicated that proofs are reusable, and newer models are becoming more efficient. For example, Opus 5.5 solved half of the proofs with about 40 percent fewer tokens than its predecessor, Opus 5.

This development strengthens the argument for software automation. If AI can both write code and prove its correctness under defined conditions, the industry focus shifts from whether AI can program to whether it can guarantee safety. This could lead to significant cost savings in the entire coding process, as developers spend less time on manual review. The ability to trust AI-generated software more confidently may accelerate the adoption of automated development workflows.

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 efforts succeed, the consequences could extend well beyond coding tools, potentially transforming how critical software is developed and maintained across the tech industry.

The project represents a major leap in AI-driven software engineering. By combining the generative power of Claude with the rigor of formal methods, Anthropic and Theorem have shown that automated proof generation is feasible at scale. This approach could redefine quality assurance in software development, making rigorous verification accessible to a broader range of projects.