Claude Mathematically Proves Code Safety in Weeks

Software verification has long been a bottleneck, reserved for high-stakes systems like aircraft controls because it demands immense human effort. Now, a partnership between Anthropic and Theorem has demonstrated that artificial intelligence can handle this tedious, critical work autonomously and at scale.

The approach addresses a core challenge in AI-generated software: proving correctness. Historically, formally verifying even a small operating system kernel like seL4 required 20 person-years of specialist labor. This cost kept the method out of reach for most commercial software. By using Anthropic’s Claude model, the team compressed this timeline from decades to weeks, marking a significant shift in how code safety is established.

The project involved Claude analyzing 123 open-source libraries from Google’s OSS-Fuzz security project. Instead of writing new software, the model translated existing crash tests into mathematical problems and analyzed compiled machine code. In just a few weeks, Claude generated approximately 180 million lines of mathematical proof code. An independent verification program named Rocq automatically checks these proofs, requiring minimal human intervention.

The results have revealed vulnerabilities that conventional testing missed for years. Claude identified hundreds of bugs, many of which only triggered under specific conditions such as unusually large input files or specific access sequences. 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 in an entire year. In another case, a logical error that had gone undetected for over a decade was caught.

However, the term “formally verified” carries specific limits. Anthropic notes that the proofs only hold under strict conditions, including a specific processor architecture, single-threaded programs, and inputs under 64 MB. Real-world libraries often run on varied hardware and configurations, meaning the verification does not guarantee error-free performance in every possible environment.

The computational cost remains significant, with individual proofs consuming hundreds of millions of tokens. While Anthropic has not disclosed total project costs, the efficiency gains are evident in newer models. Opus 5.5, for example, solves half the proofs with about 40 percent fewer tokens than its predecessor, Opus 5. This efficiency suggests that the process is becoming more viable for broader application.

The broader implication is a shift in software automation. If AI can write code and then mathematically prove its safety under defined conditions, developers can place greater trust in automated outputs. This reduces the time spent on manual review and lowers the overall cost of the coding process. The researchers describe the process as “fully autonomous,” although the underlying tools and formal foundations were built by humans at Theorem.

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 this trajectory continues, the industry may move beyond asking if AI can program to asking if it can prove that the code it writes is safe, potentially transforming the entire software development lifecycle.