Agent output that hasn't been tested is an unverified claim — testing is the only instrument that converts a claim into evidence the system actually works.

Principle

Your Work is Useless Unless Tested

The verification gap

A human skipping tests is a judgment call. An agent skipping tests isn't.

👤

Human engineer

skips the tests

"I've read the diff, I've run it locally, I'm confident enough to ship."

A bet. Sometimes right, sometimes wrong — the feedback comes from production. At least the claim is backed by a mental model the human actually has.

🤖

Agent

skips the tests

"The code looks correct. Task complete."

Not a bet — a gap. The agent can't verify what it produced. It reports confidence it doesn't have the tools to earn. The distance between "believes it built" and "actually built" is the exact space tests exist to measure.

If the agent's own read is the only evidence, you haven't verified — you've delegated certainty to something that cannot hold it.

The multiplier effect

An army of agents is a force — or a compounding error.

"The value of tests is multiplied by the number of agent executions that occur in your codebase." — TAC

Untested army

N agents × drift

Every run adds unverified change on top of unverified change. A compounding error machine — by the time symptoms surface, the blame is spread across a hundred commits.

Tested army

N agents × green suite

Every run is gated at the boundary where the change was made. Failure is localized to the agent that broke it. A force multiplier — proportional to N, not quadratic in regressions.

The suite doesn't just protect the feature it was written for — it protects every subsequent agent that touches the same systems. Auth tests, data-integrity tests, core-logic tests: written once, consumed by every run.

Without a suite, scaling agent throughput scales the damage. Tests are the thing that makes parallelism safe.

The hidden dividend

Tests aren't only a safety net — they free your context window.

Every ounce of attention spent asking "is this still working?" is attention not spent on what's next.

no tests — every change re-opens every question100% attention

"IS IT STILL WORKING?" · 55%

RE-READ OLD CODE · 30%

NEW WORK · 15%

green suite — the suite holds the model for you100% attention

NEW WORK · 100%

A passing suite is a cache of verified state. You stop holding "does the session handler still work?" in your head — the tests hold it. Delegate confidence to the suite; spend attention on the next thing.

Second-guessing is a context tax. A test suite is how you stop paying it.

Two instruments, not one

Testing and review answer different questions. Both are required.

Testing

"Does it work?"

Ground truthObservable behavior — disk state, HTTP responses, rendered pixels, return values.

Fails to catch: the right behavior implemented against the wrong spec. Tests can pass on a feature no user asked for.

Review

"Is it what we asked for?"

Ground truthThe spec — intent, acceptance criteria, anti-requirements.

Fails to catch: bugs. A feature can match the spec perfectly and still break at runtime.

Builder-Validator Pair runs both: the builder's Stop hook verifies tests pass — the validator audits the diff against the spec as ground truth.

A feature that passes tests but misses the spec is wrong. A feature that matches the spec but breaks in prod is wrong. You need both instruments or neither is enough.

How this gets violated

The patterns that let untested work ship.

Anti-patterns

• Shipping agent-generated code without running the tests at all.
• Treating tests as optional because the agent "looked correct".
• Manual testing via browser-clicking instead of automated validation.
• Build pipelines with no test phase — just lint and deploy.
• Accepting a PR without a coverage requirement on the changed surface.
• Saying "I'll add tests later" — in agentic systems, later means never.

Each pattern is a way of claiming without proving. The principle is falsified by any one of them.

The discipline

Self-reported completion is a claim. A green test run is evidence.

Testing isn't a phase after engineering — it's what converts work into something that has happened. Until the suite goes green, the agent has produced text that describes a system, not a system.