Anthropic's Claude can now automatically produce code and verify its safety.

Title: Anthropic Uses Claude to Verify 123 Open-Source Libraries

Meta Description: Anthropic's Frontier Red Team and Theorem used Claude to generate proofs for 123 OSS-Fuzz libraries, finding long-lived bugs while exposing strict limits.

Tags: Anthropic, Claude, formal verification, OSS-Fuzz, AI coding

Featured image: abstract blue and white mathematical proof lines over layered code blocks, no text, no logos, no people

Anthropic has used Claude to formally prove parts of existing open-source software correct, a move that pushes AI beyond code generation and into a field once considered too costly for routine use. Working with Theorem, Anthropic's Frontier Red Team let the model produce roughly 180 million lines of mathematical proof code in a few weeks, drawing on test programs from 123 open-source libraries in Google's OSS-Fuzz security project. The result suggests AI may help review software that humans can no longer check one line at a time, but the method also carries narrow conditions and heavy compute costs.

Why formal verification was rare before AI

Formal verification aims to prove that software behaves correctly under defined rules rather than relying only on tests. It has been prohibitively expensive in practice: verifying the small operating system kernel seL4 required a team of specialists and 20 person-years. That cost reserved such work for extreme cases such as Airbus avionics software.

Anthropic's approach changes the labor model. Claude checked existing software rather than writing new code, translating crash tests into mathematical problems, analyzing compiled machine code, and producing extensive proofs. The generated proofs were checked by an independent verification program called Rocq. Anthropic says the process requires almost no human review, and the researchers describe the generation of proofs as fully autonomous, while noting that the tools and formal foundations were built by humans at Theorem.

Bugs found during proof generation

The project did more than produce proof artifacts. While attempting to verify code, Claude encountered hundreds of bugs and was allowed to fix them itself. Anthropic says many would have escaped conventional testing because they appear only under specific conditions, such as unusually large input files or a particular sequence of accesses.

In one case, while verifying a widely used PDF reader, the team found as many security bugs in one week as are typically reported for that software in an entire year. In another application, Claude caught a logical error that had gone undetected for over a decade. Anthropic also says that even when a complete proof ultimately fails, the attempt still surfaces real bugs. That distinction matters: a failed proof is not simply wasted compute if it exposes unsafe behavior in libraries used by many programs.

Limits: verified does not mean error-free

Anthropic acknowledges that formally verified does not mean error-free. The proofs only hold under strict conditions: a specific processor architecture, single-threaded programs, and inputs under 64 MB. Real libraries often run on different hardware and in different configurations, so the guarantee is narrower than the phrase "proved correct" might suggest.

The compute cost is also steep. Individual proofs ran up hundreds of millions of tokens, and Anthropic does not report total project costs. A smaller test run showed that proofs are reusable, and newer models are getting more efficient: Opus 5.5 solves half the proofs with about 40 percent fewer tokens than Opus 5. If verification becomes cheaper, developers may spend less time reviewing AI-generated software, saving costs across the coding process, not just proof generation.

What to watch next

The project strengthens a larger case for software automation. If AI can write code and prove its correctness under defined conditions, the central question shifts from whether AI can program to whether AI can prove that the code it writes is safe. Anthropic expects formal verification with AI to soon become as practical as standard testing, and Theorem's roadmap targets critical infrastructure such as glibc, OpenSSL, and cURL. The next signal to watch is whether proof workloads can scale beyond controlled benchmarks and whether the narrow conditions can be widened without losing reliability.