Microsoft PDD Kit Explained: The Proof That Checks AI-Written Rust Code

Microsoft PDD Kit is Microsoft Research’s answer to the most awkward question in modern software development: how do you trust code you never read? Published on 5 November 2026, the Proof-Driven Development Kit turns a developer’s plain-language intent into a formal specification, then uses mathematics — not another round of human review — to prove that the code an AI agent wrote actually does what was asked. Where a proof cannot reach, it falls back to tests, and it labels every result honestly as proof or evidence.

The timing matters. Coding agents now ship whole features in a single sitting, often tens of thousands or hundreds of thousands of lines at a time. Reading every line of a pull request no longer scales, and the usual replacement — agree a plan with the agent, then trust the tests it writes — has a quiet flaw: the agent’s tests usually check what it built, not what you asked for. Microsoft PDD Kit closes that gap by making the plan enforceable. The specification becomes the contract, and a machine-checked proof holds the code to it for every possible input, including the edge cases no test suite thought to try.

This guide explains what Microsoft PDD Kit is, how its workflow runs inside GitHub Next’s Chopin planning environment, what it proved in its Pet Store demonstration, where the proof stops, and — just as important — what it cannot do yet. Microsoft is clear that this is a research prototype, not a product you can download today, and this article keeps that limit in view throughout. Every claim about the demonstration comes from Microsoft Research’s own write-up, and where Microsoft is the only source, this article says so.

Table of Contents

Microsoft PDD Kit developer using an AI coding assistant to review Rust code in an editor

What Is Microsoft PDD Kit?

Microsoft PDD Kit is a research prototype toolkit for a new way of building software that Microsoft calls Proof-Driven Development, or PDD. It was introduced by Microsoft Research in a blog post dated 5 November 2026, written by research software engineer Alex Lavaee and senior principal researcher Matthai Philipose, and built in collaboration between the Microsoft Research Catalyst Lab, GitHub Next and the Research in Software Engineering group. GitHub Next had previewed the same idea in late October 2026, and the November post is the full technical write-up.

The idea is simple to state and hard to build. A developer describes what the code should do in ordinary language. Microsoft PDD Kit asks the questions a careful reviewer would ask, records the answers in a plain-language document called an intent artifact, and turns the parts that can be formalised into a specification written in Verus, a proof language for Rust. A coding agent then writes the implementation and the proof, and Verus — a verifier co-developed by Microsoft Research, Carnegie Mellon University, VMware Research, ETH Zurich and several other institutions — checks the proof mechanically, using the Z3 solver.

If the code could fail the specification for even one input, the build fails and Verus points at the clause that broke.

What cannot be proved is not hidden. Microsoft PDD Kit converts the rest of the intent into informal specifications and generates tests for them, then labels each result for what it is: a mathematical proof, or evidence from tests. The boundary between the two is called the Trusted Computing Base, and the developer signs off on every piece of it. Nothing in the workflow asks you to have a formal-methods background. As the Microsoft Research post puts it, the toolkit is to formal methods roughly what Spec Kit is to Spec-Driven Development: it brings a specialist discipline within reach of ordinary engineers and everyday applications.

That framing is the point. Formal verification has traditionally belonged to safety-critical systems — aircraft controls, cryptographic libraries, operating-system kernels — where specialists spent months or years writing proofs many times larger than the code itself. Microsoft PDD Kit argues that two things have changed: coding agents can now help generate formal proofs from well-defined specifications, and they can also help write the specifications in the first place. The expensive part of formal methods was never the mathematics; it was the labour. If agents absorb the labour, the mathematics can move into ordinary web applications, starting with the parts where a bug costs the most: login, payments and permissions.

Why Code Review Cannot Keep Up With AI Agents

To understand why Microsoft PDD Kit exists, start with the review problem it is trying to solve. A few years ago, a pull request meant a few hundred lines written by a colleague, and a careful reviewer could read all of it. Today, a coding agent can deliver an entire feature in one sitting — tens of thousands of lines, sometimes hundreds of thousands — and the reviewer is expected to approve it. Microsoft’s own framing is blunt: reading every line of the pull request does not scale to this new way of working.

Most teams have already adapted, and the adaptation is the plan. The developer describes what they want, goes back and forth with the agent until the plan and the proposed tests look right, and hands the plan off for implementation. The plan is meant to be the contract between the developer and the agent. But as the Microsoft Research post observes, nothing actually constrains the agent to follow it. The agent can drift — implementing something slightly different from what was agreed — and then write tests that pass for the code it built rather than the code that was requested.

Continuous integration fills up with a profusion of low-quality, high-quantity tests, coverage figures look healthy, and the gap between what was asked for and what shipped stays hidden until a bug report or a nasty edge case exposes it.

Agent-written code fails in two ways a careful reviewer would usually catch: it leaves out something obviously necessary, or it does something obviously wrong. Tests alone do not close that gap, because a test suite only exercises a tiny slice of what a program can do. A test proves the code worked on the inputs it tried. A proof shows the code meets its specification for every input, including the ones the test suite missed. That is the difference Microsoft PDD Kit is built on: review asks whether code looks right, while a proof answers whether it is right — at least, right against the specification it was given.

The distinction matters for a second reason. When an agent writes both the code and the tests, the tests are not an independent check; they share the agent’s misunderstandings. A proof breaks that symmetry. The specification comes from the developer’s intent, reviewed by the developer, and the verifier is a deterministic machine that has no opinion about what the agent meant to do. If the code and the specification disagree, the proof fails, and it fails loudly.

Microsoft PDD Kit code review workflow — a developer reviewing agent-written code on screen

How Microsoft PDD Kit Works: From Intent to Proof

Microsoft PDD Kit runs as a partner inside Chopin, GitHub Next’s real-time, multiplayer planning environment, where a team and its agents can plan in one shared document. The workflow has two halves. First, team members settle intent in plain language. Then machines check the code against what was settled. Between the two sits the intent artifact, a document that bridges the user’s words with the formal specification or the tests that will check them.

Three workflows carry the process from start to finish. The first, called pdd-plan, reads the code and asks questions before anything is written. The second, pdd-prove, turns the approved plan into proofs and tests, then hunts for gaps. The third, pdd-ship, adds the verification check to continuous integration so that every later change — by a person or an agent — has to keep proving against the same specification. The sections below follow the same order the Microsoft Research post uses, because the order is part of the design: intent first, code second, proof third.

Step 1: Questions Before Code in Microsoft PDD Kit

Microsoft PDD Kit’s planning workflow, pdd-plan, reads the existing code and comes back, before writing anything, with questions in a Decisions tab. When a question depends on how the code works, the decision card explains that part first — the goal, how the pieces fit, and the exact function involved — so the developer can answer without opening the source. The point is to catch ambiguity while it is still cheap, before any code exists to argue about.

The first decision card in the demonstration shows why this matters. The developer’s request said, in effect, that you only get a token with the right password. On its own, that sentence rules out the bad case — a wrong password getting a token — but it is also perfectly satisfied by a login that refuses everyone. A login that refuses every user, right password or not, keeps the promise exactly.

The other half of the meaning is that the right password always works. Formally, the first is an implication and the second is its converse; together they make an “if and only if”. An agent left alone would pick one reading without telling anyone. In the demonstration, the developer picked both ways, and that choice shaped everything the proof later had to establish.

This is the kind of ambiguity that ordinary agent workflows settle silently. A human reviewer might catch it in a plan review, or might not. Microsoft PDD Kit makes the choice explicit, records it, and derives the specification from it — so the proof later enforces the reading the developer actually chose, not the one the agent guessed.

Step 2: A Human-Readable Intent Map

As the conversation goes on, Microsoft PDD Kit keeps a “rough work” section at the top of the plan, so a developer can follow what has been agreed without scrolling back through a long chat. It includes a flowchart of the feature being specified, a map of what will be proved and what will be trusted, and — when a picture helps — a mental model. For login, the toolkit drew a ticket desk: the field you send picks the window, the window picks the table and with it the role, and nothing prints until the password matches.

Below that sits the intent map, which ties each requirement back to the developer’s own words and records how it was settled. Each entry links to the section of the formal specification that models it and to the tests that cover it, and the specification section shows snippets of the Verus contract, annotated so the developer can see how the formal text models their intent.

The intent map is the document the team actually reviews. Nobody needs to read the proof, because the coding agent writes the proof and Verus checks every step of it. If Verus accepts the proof, it holds whether or not anyone reads it. The specification is what the proof is held to, so the specification is what people review — and it is short enough, Microsoft says, to learn to read in a few minutes.

Step 3: Proving the Login Function

Before anything gets built, Microsoft PDD Kit asks the team to sign off on the plan as a whole. Its first draft proved the decision at the centre of login — picking the table and gating on the password — and kept the handler around it trusted and tested. That is a sensible default, and it is what the toolkit recommended.

But the developer wanted more. The handler is where the lookups get awaited and the token gets signed, and that glue is exactly where a refactor can quietly swap two lines. So at intent review the developer chose to give the login handler its own asynchronous specification, so the proof covers that glue too instead of trusting it.

That choice moved almost everything into the proof and left the login handler with nothing to do but unpack the request. A new asynchronous function, called login_flow, carries the contract from the request’s fields all the way to the token or the HTTP error. Microsoft PDD Kit then brought the revised plan back for a fresh sign-off, because matching the developer’s intent is not the same as proving it, and the toolkit does not approve new trust or a wider scope on its own. Every expansion of what gets proved — or what gets trusted — comes back to a human for approval.

Step 4: Where Proof Stops

There are plenty of things a proof cannot say about a program, and login runs into most of them. Some code sits outside the verifier’s view: the bcrypt hashing, the sqlx database queries and the jsonwebtoken signing all live in other crates that Verus cannot check.

Some facts belong to the outside world: what the database holds right now, and what time the clock says, are inputs to the program, not something its code can establish. A proof also says nothing about whether, or how fast, something finishes — the specification describes what you get if login answers, and a hung or slow query breaks nothing in it. And some things only a person can judge, like whether an error message helps or a screen makes sense. Finally, a proof covers its specification and says nothing about requirements nobody wrote down.

That is where empirical verification comes in. Microsoft PDD Kit spells out the trusted boundary — the part of the Trusted Computing Base this proof leans on — wraps each trusted piece in a small function with an assumed contract, asks the developer to accept each one on its own, and writes a test for every assumed clause into the plan.

For login, the developer signed off on six pieces, covered in detail in the trusted-boundary section below. Every assumed clause then gets an empirical check in the plan, written as Given/When/Then scenarios before any test exists. An entry says “planned” until it has run, and then it records the command’s result and the commit it ran against.

Step 5: Reading the Specification

Each function in Microsoft PDD Kit gets an ensures block: statements about its result that must hold for every possible input. Verus checks them when the code builds, and if any clause could fail for even one input, the build fails and Verus points at that clause. Each clause reads as an if-then, and the Microsoft Research post takes one apart to show how a developer reads it.

The clause for the first requirement says, in effect, that if a login returns a token, then the request names a valid account, the password matches the stored hash, the token contains valid claims, and the token’s subject and role match the authenticated account.

The telling detail is that the same account appears on every line, which ties the password check to the token. Imagine a bug where login checks the password against one account but signs the token for another: Bob logs in with his own, correct password and gets back a token for Alice’s account. Each step looks fine on its own, but this clause catches it, because the password check and the token have to name the same account. That is the kind of wiring bug a test suite rarely thinks to look for — and the kind that hands an attacker someone else’s account.

The specification also has to talk about SQLite, bcrypt and JWTs without running any of them. It does that with uninterpreted functions — names with no body, such as customer_on_file for the row the database holds, bcrypt_verdict for what bcrypt would say, and token_claims for what a token carries. Verus knows nothing about them except what the trusted contracts promise. The proof says, in effect, “whatever the database holds, login does the right thing with it”, and a trusted contract says “the lookup returns what the database holds”. Code like this is called ghost code, because the verifier checks it but the compiler erases it from the program.

Step 6: Prove, Check, Close the Gaps

Signing off on the specification is where the developer’s review ends. Everything after it — the implementation and the proof — is checked by machines, which is why the Microsoft Research post spends its time on the specification and not the proof. Once the developer signs off, a Build plan stage hands the approved plan to pdd-prove, which turns it into a small task graph. For login, that is seven tasks: get the verified login file building under Verus inside the backend crate, prove the decision, the token and the whole flow, then write the tests for the trusted wrappers and the end-to-end login.

Each task runs the same loop. A coding agent writes the implementation and the proof, and Verus checks them against the derived formal specification. Anything in the trusted boundary gets the tests the plan called for. Then an LLM verifier reads the plan, the specification and the results side by side, and looks for gaps: requirements with no proof and no passing check.

Gaps go back to the coding agent until none remain. If the specification itself has a gap, such as two requirements that contradict each other, it comes back to the developer as a decision. The loop is strict about not moving the goalposts: if an asynchronous construct cannot be expressed in the pinned version of Verus, the task stops and asks the team instead of switching to a simpler helper or weakening a contract.

Step 7: Review Intent Alongside Verified Code

When the tasks pass, pdd-prove opens pull requests. They add a verified crate with login_flow, its pieces, their proofs and the trusted wrappers with their tests, and they route the real login handler through login_flow, keeping the existing HTTP status codes. The verified logic integrates with and hardens the production login path; it is not a copy of it. The developer was able to merge without relying on exhaustive line-by-line review of the generated code, because the review had already happened on the intent artifact, where the team has the final say. The pull request works as a receipt, and its description marks every login requirement as either formally verified or empirically checked.

Merging is where the proof joins the team’s normal workflow. Microsoft PDD Kit’s pdd-ship workflow adds the Verus check to continuous integration next to the empirical tests, so every later change to login — by a person or an agent — has to keep proving against the same specification, and a broken proof fails the build like a failing test. And because a proof covers every input, Microsoft PDD Kit prunes tests that only re-check what is already proved, such as example-based tests of the password gate, and keeps the ones that guard the trusted boundary — so continuous integration gets stronger and leaner at the same time.

The Pet Store Demo: A Login Proved, Not Just Tested

To show that Microsoft PDD Kit integrates with existing codebases, the team built Pet Store, a full-stack web application written entirely in Rust. The backend uses the Axum web framework and SQLite, and it handles inventory, promotions, orders and checkout. The storefront is a Leptos application compiled to WebAssembly.

Together, the two halves come to about 5,000 lines of Rust. For the blog post, the team focused on formally verifying the login logic, but Microsoft says the same process can verify the functional correctness of the entire application — and recommends starting with the most sensitive parts and verifying the rest one piece at a time. A login bug can hand an attacker a customer’s account or an admin’s controls, so that is where proof effort pays off first.

The developer’s whole request in Chopin was two sentences: “Verify the login logic in backend/src/handlers/auth.rs. Here are my requirements: 1. You only get a token with the right password. 2. Only admin accounts get admin tokens.” The team kept the request rough on purpose. Capturing the intent of the user and turning a rough request into something a proof can check is Microsoft PDD Kit’s job — and the roughness is the point. Real developers do not write formal specifications; they write two sentences and expect the tooling to do the rest.

The result, according to Microsoft Research, is that Verus hardened the code and uncovered existing bugs, proving the absence of login bugs with respect to the specification. The developer reviewed the intent and never read the generated code line by line. Note the careful wording: the proof shows there are no login bugs with respect to the specification. A proof is only as strong as the specification it checks, which is why so much of Microsoft PDD Kit is built around getting intent right first — and why the limits in the next sections matter as much as the headline.

Microsoft PDD Kit login security — the Pet Store login proof protects passwords and tokens

Eight Promises From Two Sentences

The two-sentence request, plus the “both ways” decision from Step 1, ended up as eight ensures clauses on login_flow, the asynchronous function that carries the whole login from the request’s fields to the token or the HTTP error. Four of those clauses keep today’s refusal behaviour, so the storefront and the existing API tests keep working. In plain language, the eight promises are:

  • No identity, no entry: if neither an email nor a username is sent, login returns a 400 Bad Request with today’s message.
  • A token only for the right password: if login returns a token, it is for the account the login names, with that account’s correct password, carrying that account’s id and its table’s role.
  • The right password always works: the right password for the named account always gets a token, unless a lookup or signing failure returns a 500.
  • Unknown accounts are refused: a login naming an account nobody holds gets a 401 Unauthorized, unless the lookup fails with a 500.
  • Wrong passwords are refused: a wrong password for an account whose hash bcrypt can read gets a 401, unless the lookup fails with a 500.
  • Unreadable hashes fail safely: an account whose stored hash bcrypt cannot read gets a 500 and no token.
  • Admin tokens only for admins: the admin role appears only for an admins-table row found by username, with no email sent.
  • Email logins stay customers: a token from an email login always carries the customer role.

Five functions carry those promises, each with its own contract, and Verus proves login_flow using only those contracts, without re-reading the function bodies. The pieces are login_flow itself, login_core, which awaits the lookup and calls the password gate; lookup_target, which picks the table; decide_login, the password gate; and issue_token, which signs the token or maps a refusal to today’s HTTP error. Because each piece has its own contract, changing the body of decide_login means only decide_login gets proved again — the rest of the proof stands. That composition is what makes the approach practical for a real codebase: verification effort stays local to the code that changed.

The smallest piece shows how readable the contracts are. lookup_target takes an email and a username and promises three things: an email, when sent, wins, and the search goes to customers for exactly that email; with no email, a username sends the search to admins for exactly that username; with neither, the login is refused for missing an identity. decide_login promises that no row found means Unauthorized — the same answer as a wrong password, which matters, because returning different errors for “no such account” and “wrong password” would let an attacker enumerate accounts — and that claims come back only for a found row whose stored hash matches the password.

Microsoft PDD Kit Rust code with structs and verification-ready functions in a code editor

The Trusted Boundary: What the Proof Takes on Trust

Every proof rests on assumptions, and Microsoft PDD Kit makes them visible instead of burying them. The trusted boundary for Pet Store’s login is six pieces, each wrapped in a small function with an assumed contract, each accepted by the developer on its own, and each covered by tests. They are:

  • The two lookups — Customer::find_by_email and Admin::find_by_username. Each awaited, successful lookup returns exactly the row its own table holds for that email or username, or none. The SQL query itself runs in sqlx, which Verus cannot check, so the contract is assumed and the tests check it against the real database schema.
  • check_password — a thin wrapper around bcrypt::verify. It errors only on a stored hash bcrypt cannot read, and Ok(true) means exactly the right password. Every password promise of login_flow rests on this one wrapper, which is why Microsoft calls it out as carrying most of the weight.
  • generate_token — which signs exactly the claims it is given under the configured secret and reports a signing failure as a 500.
  • expiry_from_now — which reads the clock and writes an expiry exactly 24 hours later (86,400 seconds). The clock itself is outside the proof, and the wrapper can panic if the time is out of range, as today’s login does; that panic is not promised against.
  • database_error — which turns a failed lookup into today’s 500 with sqlx’s message.
  • The login handler shell — which unpacks the request and passes its fields to login_flow unchanged.

Microsoft is upfront about the weakest links. The guarantees are only as strong as those six trusted pieces, and two carry most of the weight: check_password for every password promise, and the two lookups for every promise about which account a token names. Tests support them, but nothing proves them.

The team says it expects the trusted boundary to shrink significantly over time, so a growing share of the code can be formally verified. Until then, the honest way to read the result is that the proof covers the wiring — the decisions, the role checks, the error mapping — while the cryptography, the database and the clock are taken on trust and checked by tests.

That honesty is a feature, not a footnote. A tool that claimed “fully verified” without naming its assumptions would be more dangerous than a tool that admits its limits, because teams would stop testing the parts the proof does not cover. Microsoft PDD Kit labels every result by the kind of verification it rests on, so a team can see at a glance which promises are proved for every input and which are only evidenced by tests.

What the Proof Does Not Say

Microsoft’s own summary of the result is worth quoting in full, because it is a model of how to state a verification claim without overselling it. Three categories, no more and no less:

  • Proved: the bodies of login_flow, login_core, lookup_target, decide_login and issue_token meet their contracts for every input. Login picks the right table, compares the request’s password against the stored hash of the account it names, issues a token with that account’s id and the role its table gives, and refuses everything else with today’s 400, 401 or 500 and no token.
  • Trusted and tested: the two database lookups, check_password over bcrypt, the clock, token signing, the database error message and the handler’s request unpacking sit outside the proof, each behind an assumed contract the developer accepted. Tests against the real bcrypt, the real SQLite schema and the real router cover them.
  • Assumed: the Verus, Rust compiler and Z3 toolchain, and Verus’s standard library, vstd.

Beyond those three categories, there is a fourth list: what nobody is promising at all. The proof does not promise that the login future ever completes — a hung database query breaks no clause.

It does not promise that an out-of-range clock will not panic. It says nothing about the timing or rate of login attempts, so rate limiting and brute-force protection are separate concerns entirely. And it says nothing about how other endpoints read the role carried by a token. A proof covers its specification and says nothing about requirements outside it, which is why the specification’s completeness is the real review task — and why Microsoft PDD Kit spends most of its effort on intent.

There is one more limit worth stating plainly. Microsoft gives no bug count and no proof cost for the demonstration — the post says Verus “uncovered existing bugs” without listing them, and the write-up does not say how long the proofs took to produce.

The FAQ does say that checking a proof usually takes seconds for a small module and up to minutes for a larger codebase, and that the check is deterministic, with no model involved. But producing a proof — the labour of writing it — is where the real effort sits, and Microsoft is candid that proofs still take real effort, mostly in producing the proof itself. A clear specification is what keeps that effort down.

Vibe Verification and the Mutation Check

The sharpest idea in Microsoft PDD Kit may be its defence against a failure mode the team calls “vibe verification”. When a model writes its own specification, or is tuned to produce proofs, it tends to land on weak invariants: clauses that verify but rule out almost nothing. They prove something — just rarely the thing you care about. A specification that says “login returns either a token or an error” would verify trivially and protect nobody. The proof would pass, the team would feel safe, and the safety would be an illusion.

Microsoft PDD Kit guards against that with a mutation check. During pdd-prove, the toolkit plants one bug per ensures clause in a scratch copy of the code — for example, a login that refuses everyone, or one that checks the username before the email — and Verus has to reject each mutant on the clause it targets.

A mutant that gets through means that clause constrains nothing, and it comes back as a gap for the coding agent to fix. In other words, the toolkit does not just check that the proof passes; it checks that the proof would fail if the code were wrong. A proof that cannot fail is not a proof — it is a rubber stamp.

Two reviewer agents add a second layer of defence. Before the plan comes back to the developer, they poke holes in the derived formal specification from the intent artifact, checking that the specification matches what was asked for and does not promise more than a proof could show. The specification refinement runs in the background and takes live user feedback, iterating until the reviewers agree that the specification is sound. Between the mutation check and the reviewer agents, Microsoft PDD Kit is designed around a single insight: a proof is only as good as its specification, so the specification deserves more scrutiny than the code.

Microsoft PDD Kit mathematical proof concept — equations on a chalkboard

Microsoft PDD Kit vs Spec-Driven and Test-Driven Development

Microsoft PDD Kit keeps the planning loop from Spec-Driven Development and still uses tests where a proof cannot reach. What changes is what holds the code to the plan. The Microsoft Research post’s own comparison makes the difference clear:

Approach What checks the code
Spec-Driven Development Nothing enforces the specification
Test-Driven Development Tests on a sample of inputs, often written to match what was built
Agent checks its own work The same model that wrote the code
Proof-Driven Development Verus automatically verifies the proof that the code satisfies the specification the developer approved

The table is worth reading slowly, because each row names a real failure. In Spec-Driven Development, the specification is a document the agent is asked to follow, and nothing checks whether it did.

In Test-Driven Development, the tests sample inputs — and when the agent writes them, they often encode the agent’s own behaviour rather than the requirement. When an agent checks its own work, the checker shares the writer’s blind spots. Proof-Driven Development is the first row where the checker is independent of the writer and exhaustive over the inputs the specification covers. A test checks some inputs; a proof establishes that the code satisfies specified properties for all inputs covered by the formal model, under its stated assumptions.

That does not make tests obsolete, and Microsoft PDD Kit does not pretend otherwise. Tests remain the only check for everything a proof cannot reach: third-party libraries, user interfaces, timing, and anything a person has to judge. The toolkit’s contribution is a division of labour. Proofs cover the logic that can be specified exactly; tests cover the boundaries that cannot. And because a proof covers every input, the toolkit prunes tests that only re-check what is already proved, keeping the suite focused on the trusted boundary where tests are the only defence.

Why Rust, and Why Only Rust for Now

Microsoft PDD Kit only verifies Rust today, because that is the language Verus works on. If a codebase is already Rust, there is nothing to migrate. Code in other languages can be ported to Rust and checked against the same specification, and non-Rust projects can call verified Rust through bindings. The techniques behind the toolkit could, Microsoft says, help put other proof languages to work as well — the post names Lean, F* and Rocq as examples, each with its own trade-offs — but Verus was chosen because it lets developers verify Rust code directly, inside existing Rust development workflows, without learning a new language for specifications and proofs.

There is also a less obvious upside to the Rust-only constraint. Once a team no longer relies on exhaustive line-by-line review, readability stops being the main reason to pick a language. A team can pick a language for speed and safety, and optimise as hard as it wants, because any change that breaks the specification fails the proof.

That argument will resonate with Rust teams in particular: Rust already trades a steep learning curve for memory safety without a garbage collector, and Microsoft PDD Kit extends the same bargain from memory safety to full functional correctness, with no runtime cost — the ghost code is erased before compilation, so the proof adds nothing to the running program.

Verus itself is an open-source project, available at github.com/verus-lang/verus, and it is already seeing industrial use at Microsoft and Amazon, according to its community materials. The verifier is an SMT-based tool: developers express proofs and specifications using the Rust language, and Verus checks them with the Z3 solver. For teams that want to experiment with the underlying technology while Microsoft PDD Kit remains a research prototype, Verus is the accessible piece — it is open source, documented, and usable today without Chopin or the toolkit around it.

Can You Use Microsoft PDD Kit Today?

The short answer is no — not yet, and not as a product. Microsoft calls Microsoft PDD Kit a research prototype, and the November 5 write-up gives no general-availability date, no public download and no pricing. The toolkit runs inside Chopin, GitHub Next’s planning environment, which GitHub Next itself lists as a research prototype, and reporting on GitHub Next’s preview characterises access to Microsoft PDD Kit as a limited research preview. Readers should treat it as an approach worth understanding, not as a tool to install on Monday.

That status matters for how to read the demonstration. Pet Store’s login is one piece of one application: a specification anyone can read, a Verus proof that the code matches it, and tests for everything the proof takes on trust. Microsoft says it wants to find out how far the approach scales, and that the trusted boundary should shrink over time.

Until it does, the practical way to use the ideas in Microsoft PDD Kit is to borrow the discipline without the tooling: write the intent down before the agent writes code, decide the ambiguous cases explicitly, name what you are trusting, and test the trusted parts hardest. Those habits improve any agent workflow, with or without a proof at the end of it.

For teams that want to follow the work, the primary source is the Microsoft Research blog post, “Formally verifying agent-written full-stack web apps with PDD Kit”, published 5 November 2026. The Verus project is open source and independently usable, and GitHub Next’s Chopin is the environment where the toolkit runs. None of those gives you Microsoft PDD Kit itself today — but they are the pieces it is built from, and they are all public.

Who Should Care — and Who Should Wait

Microsoft PDD Kit matters most to teams already feeling the review problem it solves. If your agents routinely ship large pull requests that nobody fully reads, and the code touches money, accounts, permissions or personal data, the toolkit’s approach is directly relevant — even if you cannot use the toolkit itself yet. Security-sensitive Rust codebases are the natural first audience: the demonstration deliberately starts with login, and Microsoft recommends starting where a bug costs the most, then verifying the rest of a codebase one piece at a time.

Developers working in other languages should wait, but not ignore it. The pattern — intent review, formal specification, machine-checked proof, explicit trusted boundary — does not depend on Rust, and Microsoft explicitly says the techniques could extend to other proof languages. The question for a Python or TypeScript team is not whether to adopt Microsoft PDD Kit, but whether to adopt its discipline: an explicit specification, reviewed by a human, that something other than the agent enforces.

Solo developers and small teams should take a different lesson. The Pet Store demonstration shows that a two-sentence request can become eight precise promises, and that the work of turning rough intent into checkable requirements is where the value sits. A solo developer can do that part today with any agent: ask it to restate the requirements back, challenge the ambiguous cases, and write the tests from the requirements rather than from the implementation. The proof is the aspiration; the intent review is the practice, and it is available now.

Formal Methods Are Going Mainstream

Microsoft PDD Kit is not arriving in a vacuum. The same month it was published, the industry’s biggest AI labs were all pushing formal methods into everyday engineering. Anthropic reported in October 2026 that Claude had proved 123 open-source libraries free of crashes under stated assumptions — a result covered by AI Newsway the same week Microsoft PDD Kit appeared.

The same week, the Xen Project published a security advisory crediting Anthropic’s Claude with the discovery of critical hypervisor flaws, a story covered in depth in our report on Claude finding the Xen vulnerability. Meanwhile, the agent frameworks teams use to build these systems are maturing too — Google’s ADK 2.14 graduated its core modules to stable, and Meta’s Muse Spark Open brought open-weight agent models to developers. The pattern is consistent: AI systems are becoming capable enough to do the labour of formal verification, and the labs are racing to productise that capability.

That race is worth watching because it changes who formal verification is for. For decades, the field belonged to specialists working on safety-critical systems, and the cost of a proof confined it there. If agents can generate proofs and specifications at scale, the cost collapses, and the same machinery becomes available for login handlers, payment flows and permission checks in ordinary applications. Microsoft PDD Kit is the clearest statement of that ambition so far: not a better code reviewer, but a different kind of check entirely — one that does not get tired, does not share the agent’s assumptions, and does not stop at the inputs the test suite happened to try.

The counterweight is the specification problem, and Microsoft is unusually honest about it. A proof is only as good as its specification, a wrong specification is still possible, and the toolkit’s answer is process: reviewer agents, mutation checks, human sign-off on every piece of trust. That is the right answer, but it is also a reminder that Microsoft PDD Kit does not remove human judgement from software engineering. It moves judgement to where it matters most — deciding what the software should do — and lets machines handle the question of whether it does it.

Frequently Asked Questions

What is Microsoft PDD Kit?

Microsoft PDD Kit is a research prototype toolkit for Proof-Driven Development, published by Microsoft Research on 5 November 2026. It turns a developer’s plain-language intent into a formal specification in Verus, has a coding agent write the code and the proof, and uses Verus to check that the code meets the specification for every input — falling back to tests where a proof cannot reach. It runs inside Chopin, GitHub Next’s multiplayer planning environment.

Is Microsoft PDD Kit available to download?

No. Microsoft describes Microsoft PDD Kit as a research prototype running inside Chopin, and reporting on GitHub Next’s preview characterises access as a limited research preview. The November 5 write-up gives no general release date, no public download and no pricing. The underlying verifier, Verus, is open source and usable independently.

What did Microsoft PDD Kit actually prove?

In its demonstration, Microsoft PDD Kit formally verified the login logic of Pet Store, a roughly 5,000-line Rust web application. Verus proved that five functions — login_flow, login_core, lookup_target, decide_login and issue_token — meet their contracts for every input, and the developer’s two-sentence request became eight ensures clauses. Six trusted pieces, including the bcrypt password check and the database lookups, sit outside the proof and are covered by tests instead.

Does Microsoft PDD Kit work with languages other than Rust?

Not today. Microsoft PDD Kit only verifies Rust, because Verus is a proof language for Rust. Code in other languages can be ported to Rust and checked against the same specification, and non-Rust projects can call verified Rust through bindings. Microsoft says the techniques behind the toolkit could extend to other proof languages such as Lean, F* and Rocq.

How is Microsoft PDD Kit different from testing?

A test checks whether code worked on the inputs it tried. A proof, as Microsoft PDD Kit uses it, shows the code meets its specification for every input the formal model covers, under its stated assumptions. Tests remain essential for everything a proof cannot reach — third-party libraries, user interfaces, timing — and Microsoft PDD Kit labels test results as evidence rather than proof.

What is “vibe verification”?

It is Microsoft’s term for a proof that verifies but rules out almost nothing — a weak specification that passes while protecting nobody. Microsoft PDD Kit guards against it with a mutation check: it plants one bug per ensures clause in a scratch copy of the code, and Verus must reject each mutant on the clause it targets. A mutant that gets through means the clause constrains nothing.

How long does a Verus check take?

According to the Microsoft Research post, the check is deterministic, with no model involved: usually seconds for a small module and up to minutes for a larger codebase. Producing the proof takes longer, and Microsoft is candid that proofs still take real effort — a clear specification is what keeps that effort down.

The Bottom Line

Microsoft PDD Kit is the most interesting response yet to the review crisis that coding agents created. It does not ask humans to read more code, faster. It changes what humans review — from thousands of lines of generated code to a short, plain-language specification of what the code should do — and lets a machine-checked proof hold the code to that specification for every input.

The Pet Store demonstration is deliberately narrow: one login flow, five proved functions, eight promises, six trusted pieces. But the shape of it is the story. The specification is reviewed by people; the proof is checked by a machine; the boundary between proof and trust is written down and signed off; and a pull request arrives as a receipt, not a leap of faith.

The limits are real and Microsoft states them plainly. Microsoft PDD Kit is a research prototype, not a product. It verifies Rust only. The proof covers the wiring, not the cryptography, the database or the clock. And a proof is only as good as its specification — which is why the toolkit spends most of its effort on intent, reviewer agents and mutation checks rather than on the proof itself.

None of that diminishes the idea. If agents keep writing more of the world’s code, something other than the agent has to check it, and a mathematical proof is the strongest check we have. Microsoft PDD Kit shows what that check could look like inside an ordinary team’s workflow — and, for the first time, it shows it working on an ordinary web application rather than a safety-critical system. Watch the trusted boundary shrink. That is the number that will tell you when proof-driven development stops being research and starts being how software gets built.

Leave a Comment

Your email address will not be published. Required fields are marked *