Writing / Measure or guess / 5 June 2026

Confidence is earned, not granted

When writing code costs almost nothing, the scarce thing is being sure it does what you think. That confidence is a property of the system around the agent, not a favour you grant it because the tests went green.

For twenty years the expensive part of shipping software was writing the code. That is the part that just collapsed in price. An agent will produce more correct-looking code in an afternoon than a team used to write in a week.

So the constraint moves. When producing code is nearly free, the scarce resource is confidence: confidence that the code does what you think, that it hides no security or compliance problem, that someone can still reason about it next quarter. The bottleneck is no longer typing. It is trust.

The mistake is to treat that trust as something you grant the agent. The tests are green, the diff looks reasonable, so you approve it. That is not confidence, it is hope with a tick next to it. Coverage percent tells you a suite ran, not that the suite tests the thing that will break. Green on a thin suite is the most expensive kind of green, because it reads as safety.

On the left, an approval tick sits on top of the agent's output with nothing underneath it. On the right, the same output rests on a foundation of small diffs, context, tests and a second model's review. Confidence granted Confidence earned tests pass ✓ agent output nothing underneath approved because the tests were green agent output tests on every change an independent review a gate before push a human smoke test checkable without re-reading every line
Same output, same green tests. On the left the tick is the only thing holding it up. On the right the system holds it up, and the tick just confirms what the structure already made true.

Confidence is a property of the system

Real confidence is earned, and it is earned by the system around the agent, not by the agent itself. It comes in layers. Automated tests carry the routine cases. An independent review catches what they miss. On my own side project I have agents review each other’s work, so a second model has to disagree before anything lands. Gates run before anything is pushed. And a human still smoke-tests the result at the end, because someone has to own the call.

Underneath all of it sits a written trail of what was built and why, so a person keeps the overview instead of chasing the code after the fact. None of that is the model being clever. It is structure that makes the output checkable without re-reading every line.

That is the move that buys the speed everyone is chasing. The teams getting real leverage from these tools are not the ones who trust the agent more. They are the ones who built a system that earns the trust for them, so they can ship code they did not read and be right about it.

The cost does not vanish, it moves

Generate fast with none of that and you have not saved the cost of writing the code. You have moved it downstream, onto whoever has to be sure it works later. That bill always comes due. The only question is whether you priced it in or got surprised by it.

An honest read

If this sounds like your team, that is worth a conversation.

Book a call