Software engineer and writer Kieran Klaassen argues that coding agents have quietly inverted the economics of building software. Writing code used to be the expensive step. Now a model can produce a working pull request in minutes, so the cost has shifted to a harder question: does the output actually do what it claims to do. Klaassen calls the distance between an agent’s claim and its proof the verification loop, and he treats closing that gap as the central engineering problem of agentic development.
The mechanics are simple to state and hard to execute. An agent finishes a task and reports success. Somebody, or something, has to confirm that claim against reality: does the branch build, does the feature render correctly in a browser, does the fix address the actual bug rather than a symptom. For years that confirmation step was implicitly human. A developer opened the pull request, clicked through the app, and either approved or rejected it. Klaassen’s framing is that this human checkpoint no longer scales at the rate agents produce candidate changes.
That mismatch creates a specific failure mode: agents reviewing agents. When verification itself gets delegated to another model, the reviewer inherits the same blind spots as the author, because both are working from the same training distribution and the same incentive to report success. A review agent that never actually loads the running application and only reads the diff is not verification. It is a second guess dressed up as confirmation. Klaassen’s own approach leans on giving a reviewing agent something closer to a persona and a way to observe the software in a browser, so the check is grounded in what the software does rather than what the code appears to do.
The deeper point generalizes past any single technique. Verification only counts as verification when it produces evidence that is independent of the claim being checked. A test suite that the same agent wrote to prove its own change is not independent evidence. A screenshot of the actual rendered page, a passing suite the agent did not author, or a human clicking through the flow are. Teams that skip this distinction end up with pull requests that pass every internal check and still fail in production, because the checks were never adversarial to begin with.
For a team currently shipping agent-written code, the next ninety days should go toward building an evidence trail that sits between the agent and the merge button. Fix a set of browser-level checks that run on every change. Set a human spot-check quota tied to risk rather than volume. Require that any fix an agent proposes ships with the artifact that proves it, not just the agent’s own narration that it works. Teams that treat verification as a bolt-on will find their review queue growing faster than their headcount. Teams that build it into the pipeline will be the ones actually shipping.
Kieran Klaassen described the verification loop concept in a 2026 post on his Thinkroom engineering blog.
