180 Million Lines of Proof: AI Catches Hidden Software Flaws

For software developers across the region, the landscape of code reliability is shifting. A new collaboration between Anthropic and Theorem has introduced a method where artificial intelligence does not just write code, but also mathematically proves that existing software works as intended. This process has already identified hundreds of hidden errors in widely used open-source libraries, suggesting a future where verifying software safety becomes as routine as running basic tests.

The scale of the recent effort is substantial. In a matter of weeks, the Claude model generated approximately 180 million lines of proof code. This work focused on 123 open-source libraries from Google's OSS-Fuzz security project. The model did not create new software from scratch. Instead, it analyzed compiled machine code and translated crash tests into mathematical problems to build extensive proofs of correctness.

This approach addresses a long-standing cost barrier in the industry. Historically, formal verification required expensive specialist teams. For example, verifying the seL4 operating system kernel took 20 person-years. Because of this high cost, the technique was largely reserved for critical systems like Airbus avionics. Anthropic's Frontier Red Team changed this dynamic by allowing the AI to handle the proof generation autonomously.

The process involves an independent verification program called Rocq, which checks the proofs produced by Claude. According to Anthropic, the system requires almost no human reviewers. While the formal foundations and tools were built by humans at Theorem, the actual generation of proofs is described by researchers as fully autonomous. This independence allows for a faster turnaround than traditional manual review processes.

The practical impact was evident during the testing phase. While generating proofs, Claude encountered hundreds of bugs and was permitted to fix them. Many of these errors would have escaped conventional testing because they only appeared under specific conditions, such as unusually large input files or particular sequences of data access. The AI was able to identify these edge cases effectively.

One notable example involved a widely used PDF reader. In a single week, the team found as many security bugs as are typically reported for that software in an entire year. In another application, the model caught a logical error that had remained undetected for more than a decade. Anthropic notes that even when a complete proof fails, the attempt often surfaces real bugs, adding value to the testing process.

However, the term formally verified has specific limits. The proofs hold only under strict conditions, including a specific processor architecture, single-threaded programs, and inputs under 64 MB. These libraries often run on different hardware in real-world scenarios. Additionally, the compute cost is high, with individual proofs consuming hundreds of millions of tokens. Anthropic did not report the total project cost.

Despite these constraints, the project suggests a major leap in software automation. If AI can verify its own code under defined conditions, developers can place more trust in AI-generated software and reduce time spent on manual review. This efficiency could lower costs across the entire coding process. Smaller tests also showed that proofs are reusable and that newer models are more efficient, with Opus 5.5 solving half the proofs with about 40 percent fewer tokens than its predecessor.

The long-term goal is to make formal verification with AI as practical as standard testing. Theorem's roadmap already targets critical infrastructure components like glibc, OpenSSL, and cURL. If successful, the industry focus may shift from asking if AI can program to asking if it can prove that the code it writes is safe.