Automated Proof: Anthropic's AI verifies code safety at scale

For developers and tech users in the New York and New Jersey regions, the landscape of software reliability is shifting. Anthropic has demonstrated that its Claude model can not only write code but also mathematically prove that existing software is correct. This capability moves beyond standard testing by using formal verification to catch errors that traditional methods often miss, potentially leading to more stable applications for everyday use.

The process involves a significant change in how code safety is assessed. Instead of relying solely on human reviewers or basic test cases, the system uses AI to generate formal proofs. These proofs are mathematical arguments that confirm a program behaves as intended under specific conditions. This approach addresses a long-standing challenge in software engineering where verifying code has been too expensive and time-consuming for widespread use.

One key development is the speed and volume of the verification work. In a collaboration with partner Theorem, Claude generated approximately 180 million lines of proof code in just a few weeks. This effort covered 123 open-source libraries from Google's OSS-Fuzz project. The model analyzed compiled machine code and translated crash tests into mathematical problems, producing extensive proofs that required almost no human intervention to check.

A second major takeaway is the discovery of hidden defects. During the verification process, Claude identified hundreds of bugs that had been missed by conventional testing. These errors often only appear under very specific conditions, such as unusually large input files or particular access sequences. In one instance, the team found as many security bugs in a widely used PDF reader in one week as are typically reported for that software in an entire year.

The third point concerns the autonomy of the system. Anthropic describes the process as fully autonomous, meaning the AI handled the proof generation and even fixed the bugs it found. An independent verification program named Rocq automatically checks these proofs. While the underlying tools and formal foundations were built by humans at Theorem, the daily work of verifying and correcting code was managed by the model without continuous human oversight.

Context for this advancement requires understanding the historical cost of formal verification. Traditionally, proving software is error-free has been prohibitively expensive. For example, a team of specialists required 20 person-years to verify the small operating system kernel seL4. Because of this high cost, the method was usually reserved for critical systems like Airbus avionics software, leaving most commercial software without such rigorous checks.

However, the technology has practical limits. Anthropic notes that formally verified does not mean completely error-free. The proofs only hold under strict conditions, including a specific processor architecture, single-threaded programs, and inputs under 64 MB. In real-world scenarios, these libraries often run on different hardware and configurations, which means the verification covers a defined subset of possible use cases rather than every potential situation.

The financial and computational costs remain a factor. Individual proofs can run into hundreds of millions of tokens, though Anthropic has not reported the total project costs. Despite this, the efficiency is improving. A smaller test run showed that newer models are more efficient, with Opus 5.5 solving half the proofs with about 40 percent fewer tokens than its predecessor, Opus 5. This suggests that the process may become more cost-effective over time.

Looking ahead, the goal is to make formal verification with AI as routine as standard testing. Theorem's roadmap targets critical infrastructure components like glibc, OpenSSL, and cURL. If AI can guarantee the correctness of code under defined conditions, it shifts the focus of software development from writing code to proving its safety. This could lead to greater trust in AI-generated software and reduce the time developers spend on manual reviews.

The implication for the industry is a potential leap in automation. By catching bugs that have gone undetected for years, such as a logical error found in an application that had persisted for over a decade, the system adds a layer of security. Even when a complete proof fails, the attempt often surfaces real bugs. As these tools become more accessible, they may change how software is built and trusted in the coming years.