Life after the audit.

A register like that survives contact with a sprint-planning meeting: fixes sequenced by severity and reachability, budgets defensible, “what is still open” answerable without calling anyone. Each entry is delegable as well as plannable: every known issue carries a copy-ready prompt with the issue, its context and its reproducer, so any engineer or coding agent can pick up the fix with the reproducer as the finish line.

The public project shows the shape: the jsonparser register, read off master — four records, every one fixed, every one carrying the command that reproduces it. When a customer or a board member asks what you know about the component’s risks, there is a written answer with evidence behind it. The risk did not shrink; it stopped being invisible, and invisible is the expensive part.

In the corpus, the test that pins a defect carries its name (// Reproduces: KI-…) the same way verification tests carry theirs (// Verifies: SYS-REQ-…) — one public file shows both on one screen.

That grading loop does not care who wrote the fix. Assign a finding to an engineer on Monday, or point a code-writing model at it overnight; either way, the claim “fixed” is machine-checked. Teams that generate a lot of their code feel this one first: the register becomes a work queue their tooling can safely burn down. And when you would rather hand the queue to us, fix sprints are scoped separately and delivered as pull requests your engineers accept — the gate grades our fixes exactly as it grades anyone’s.

A miss is its own signal: something reached production that the audit did not catch. That has a protocol.

The defect is recorded and root-caused to the exact gap that let it through: a requirement that was never written, a test partition that was never exercised, a coverage condition no test ever made matter. Closure then requires the corrective artifacts: the missing requirement written and approved, a reproducer that pins the failure, a sweep for sibling defects in the same class.

And the class claim stays honest. One passing reproducer proves this instance is dead; claiming the whole class is closed takes more evidence than one test. The protocol has already run in public, on jsonparser: the full case is published, misses included.

Every fixed defect stays fixed, because its reproducer stands guard in your CI. Every escape makes the specification more complete. Every release adds requirements to the corpus. Nothing you have paid to learn about the component is ever un-learned.

There is a simpler name for all of this: memory. Engineering memory that lives with the code. Written-down intent; defects with their root causes; what was proven, and what was not. All of it versioned in the same repo and checked on every release. It survives departures, reorgs, and rewrites, and it is valuable enough that we treat it like source code: yours, in your repo, nowhere else.

Your coding agents draw on it the same way your engineers do: they query the graph of components, requirements, obligations and evidence directly, over MCP, and start from approved intent instead of rediscovering the system from raw code. The shape of the record is the commitment — plain files any tool can read. What the agent receives →

The gate does the mechanical half of that automatically. The human half — new requirements for new behavior, judged severities, the miss protocol, a person who validates every finding before you see it — is what the invoice buys.

And if you stop: you keep everything that runs. The corpus is plain YAML and executable tests in your git, and the gate keeps checking yesterday’s promises without us. What ends is the ongoing expertise: nobody keeps writing tomorrow’s. By month two your component has changed, and the register quietly stops being true. That is the whole trade, stated plainly.