Quality Gates for Agent-Written Code

The most common objection to agent-heavy development: "who reviews all that code?" It's the right question with the wrong assumption — that review must look like a human reading diffs.

The layered gate model

Every work unit in our pipeline passes through gates in order. Each gate is cheap relative to the next, so defects get caught at the cheapest possible layer:

1. Static gates — compilation, linters, type checks, security scanners. Free, instant, catch the mechanical failures.
2. Test gates — the work unit's contract includes tests written before implementation, by a different agent than the implementer. Implementer and verifier never share context.
3. Adversarial review — a skeptic agent is prompted to refute the implementation: find inputs that break it, invariants it violates, requirements it silently dropped.
4. Human architecture review — by the time a human looks, the question isn't "does this work?" but "is this the right shape for the system?"

Separation of context is the trick

The failure mode of naive agent pipelines is self-grading: the same context that wrote the code writes the tests, and both share the same blind spots. Independent contexts — different agents, different prompts, sometimes different models — break the correlation.

What the data says

Across our production systems, roughly 90% of defects die at gates 1–3. Human reviewers see an order of magnitude fewer problems, which means they actually look carefully at what remains.

Speed without verification is just faster failure. The gates are the product.