AlphaProof Code: A Developer's Checklist Before You Trust an AI-Verified Codebase

Shivam Kumar | VisionQuantech | November 11, 2026

Google DeepMind announced AlphaProof Code on November 10, 2026: an agentic framework that formally verified the cryptographic core of the Signal protocol — libsignal v0.105.4, compiled to AArch64 machine code — in four weeks. Agents powered by Gemini 4 Carbon generated over 6.5 million lines of Lean proof. Every proof was checked by Lean's kernel. An independent count the next day found 7,528,293 lines across 11,323 files, with zero sorry in the headline proofs.

This is the first time a widely deployed cryptographic protocol has been verified at this depth, by any method. It is also the first time most developers will have to evaluate a machine-checked proof instead of a test suite. Here is the checklist I would run before trusting one.

1. Check what was actually proved — and what was assumed

AlphaProof Code proved ten symbolic theorems: forward secrecy, post-compromise security, initiator and responder secrecy, authentication, and five corollaries of PQXDH's Theorem 1. Scope: one-to-one sessions, PQXDH handshake, Triple Ratchet, AArch64 only.

What it did not prove: group chats, linked-device state, the operating system, your phone, or the cryptographic primitives — those are modelled as assumptions. The paper is explicit that no post-quantum guarantee is established for SPQR's healing property. Before you cite a verification result, list the assumptions in one paragraph. If you cannot, you do not understand the result yet.

2. Verify the artifact yourself — it is public

The full artifact set is at github.com/google-deepmind/code-verification (commit 808b4b7, Apache 2.0). A stranger on Dev.to cloned it within 24 hours, counted every .lean file with wc -l, and grepped for sorry, native_decide, and extra axioms. You can do the same in ten minutes. A verification claim with a public repo you can audit is a different species from a benchmark table. Demand the repo, or discount the claim.

Budget for a rebuild if you want to re-run the kernel: several hours, 15–34 GiB peak RAM, Lean 4 v4.34.0 and Rust 1.98.1 pinned. That is a CI-server job, not a supercomputer booking.

3. Look for the falsifiability test

DeepMind reintroduced two real, previously fixed bugs into an isolated copy of Signal's code. AlphaProof Code produced machine-checked findings that the buggy versions violated the intended properties. A verifier that passes everything proves nothing — this one caught planted bugs. Any vendor selling you "AI verification" should be able to show you the same test: a known-bad input that their system flags. Ask for it by name.

4. Do the ratio math before you budget

My own arithmetic, from DeepMind's numbers: 6.5 million lines of proof for ~140,000 machine instructions is about 46 lines of proof per instruction, or roughly 11,600 lines of proof per kilobyte of source. That ratio — not the four-week headline — is what you budget from. A 560 KB codebase needed a 529 MB proof artifact. Verification is an artifact an order of magnitude larger than the code itself.

The throughput is equally instructive: 6.5 million lines in 28 days is ~232,000 lines a day, sustained. Agent teams ran 40–80 agents for 24–72 hours each on a single machine. That is a factory with a deterministic quality gate, not a model writing fast.

5. Find the human bottleneck — it moved, it did not disappear

The trusted base is about 26,000 lines: ~18,000 lines of specification (28,000 with documentation) plus ~8,000 lines of AArch64 semantics. Humans reviewed every specification; no author wrote any proof code. That means humans reviewed roughly 0.4% of the artifact, and the other 99.6% is trusted because Lean's kernel checked it.

The scarce resource is no longer proof-writing labour. It is specification-writing judgement. A correct proof of an incomplete specification is still incomplete security. If your team adopts this, hire and train for the specification, not the proof.

6. Keep your existing safety net

Formal verification does not replace fuzzing, penetration tests, dependency checks, or operational monitoring. Cryptography can fail outside the proved boundary — in the parts that were assumed, not proved. AlphaProof Code proves the compiled code preserves stated properties under stated models. Everything outside that boundary still needs the old tools.

The takeaway for your next project

Write down, precisely, what your system must never do. That specification is now the most valuable artifact in your security program — it is the part the machine cannot write for you and the part a human must still get right. Then let agents do the proving, and let a kernel do the judging.

The era of "the AI wrote it, so it must be right" is ending. The era of "the AI proved it, and the proof checker agrees" just started — in four weeks, for the code that protects billions of conversations.

Sources

• Google DeepMind, "Formal Verification of Signal's Protocol with Gemini," November 10, 2026
• github.com/google-deepmind/code-verification (commit 808b4b7, Apache 2.0)
• Frank Chu, "6.5M lines of Lean: I counted DeepMind's Signal proofs," Dev.to, November 11, 2026

Shivam Kumar is the founder of VisionQuantech, where he builds AI agents and automation for small businesses.