How Microsoft Proves AI-Written Code Is Correct

Minimal geometric image in charcoal, coral red and pale grey illustrating formal proof checking AI-written Rust code.

 

AI coding agents now write a large share of new code, and that creates a problem nobody has solved well: how do you know the code is actually correct? Line-by-line human review does not scale when agents produce thousands of lines at a time. Microsoft Research and GitHub Next think they have a better answer, announced on 5 November 2026: the PDD Kit. Instead of reviewing code, it proves it.

PDD stands for Proof-Driven Development: turn what you want the code to do into a formal specification, then prove the agent's code meets it for every input.

What is PDD Kit?

The PDD Kit is a research prototype from Microsoft Research and GitHub Next — not a commercial product, with no general-availability date and access limited to a research preview.

The kit works inside Chopin, GitHub Next's real-time multiplayer planning environment, where a team and its agents plan a feature together in one shared document. The plan is supposed to be the contract between humans and agents — but nothing forces the agent to follow it. PDD Kit makes the agent keep the plan. At the heart of the kit is Verus, a proof language for Rust co-developed by Microsoft Research, Carnegie Mellon University, VMware Research, ETH Zurich and other partners.

The 5-step workflow

Here is the workflow, step by step.

Step 1. Plan

The team plans the feature together in Chopin. Humans and agents share one planning document, discussing what the feature should do and how it should behave.

Step 2. Spec

The kit discusses the code with the team, infers the intent, and proposes a formal Verus specification — a precise statement of what "correct" means.

Step 3. Approve

A human approves the specification — not the code. Instead of reading thousands of lines to spot bugs, you read a precise statement of what the code must do and decide whether it is right.

Step 4. Prove

The Verus verifier proves the agent's code satisfies the specification for every input. A test shows the code worked on the cases you tried; a proof shows it cannot fail on any case.

Step 5. Fallback

Where a full proof is not possible, the kit falls back to tests and computer-use agents for empirical checking.

The end product is a verified pull request, and pdd-ship adds verification to CI so a failing proof blocks the merge.

The demo: a full-stack Pet Store

To show the kit working on something real, the team built Pet Store, a roughly 5,000-line full-stack Rust web application with an Axum backend, SQLite storage and a Leptos/WebAssembly frontend, handling inventory, promotions, orders and checkout.

Verus formally checked five core login functions — login_flow, login_core, lookup_target, decide_login and issue_token — and uncovered existing bugs.

But the demo also shows the limits honestly. Six trusted components sit outside the proof: database lookups, the bcrypt password-checking wrapper, the clock, token signing, database-error handling and request unpacking. The proof assumes these behave as described.

What are the limits?

Three limits matter most.

First, PDD Kit is Rust only today. Second, a proof covers only the properties the specification can state precisely. Third, there is the trusted computing base, or TCB: the code the proof assumes behaves as described.

Why it matters

As agents write more code, faster, the old model — a human reading every line — breaks down. It is slow, error-prone, and wastes the scarcest resource in software development: careful human attention. Proof-driven development changes where that attention goes: instead of reviewing code, humans review intent, and the machine does the exhaustive checking.

Key takeaways

  • PDD Kit, from Microsoft Research and GitHub Next, proves AI-written Rust code meets a formal specification.
  • It is a research prototype, not a commercial product; there is no general-availability date.
  • The 5-step workflow: Plan, Spec, Approve, Prove, Fallback — a human approves the spec, not the code.
  • In the Pet Store demo (about 5,000 lines of Rust), five login functions were formally checked and the proof uncovered existing bugs.
  • Six trusted components sit outside the proof, including database lookups and token signing.
  • Limits: Rust only today, proofs cover only what the spec can state, and the trusted computing base must be kept small.

Conclusion

PDD Kit is a prototype, it works in one language, and it can only prove what can be written down precisely. But it points at a future that feels inevitable: as agents write more of our software, we will stop checking their work line by line and start checking it by proof.

FAQ

What is Microsoft's PDD Kit?

PDD Kit is a research prototype from Microsoft Research and GitHub Next that turns plain-language intent into a formal Verus specification, then proves AI-generated Rust code satisfies that specification for every input. It is not a commercial product, and no general-availability date has been announced.

How does the PDD workflow work?

Five steps: Plan in Chopin, Spec in Verus, a human Approves the spec, the verifier Proves the code meets it, and Fallback to tests where a full proof is not possible.

What are the limits of PDD Kit?

Rust only today; proofs cover only what the spec can state; trusted components such as database lookups and token signing sit outside the proof. It is in limited research preview, with no public download date.

Sources

Related reading on Daily Tech & AI:

Researched with AI assistance and reviewed for accuracy.

Follow on WhatsApp

Follow Daily Tech & AI on WhatsApp for the latest tech and AI updates: https://www.whatsapp.com/channel/0029Vb9XzdHDJ6H4TFNAl61r

Comments