Published portfolio view — clean read
← All writing
Engineering · AI · Craft ·November 1, 2026 ·10 min

Code got cheap. Verification didn't.

Writing code is no longer the expensive part of software. Most teams haven't noticed where the cost went, and are cutting exactly the thing they now need most.

I haven’t written code by hand in months, and I don’t read most of the code that runs the things I build. That’s not a confession. It’s the starting point for an argument about where the cost of software actually went.

The expensive step moved

For the entire history of our industry, writing the code was the expensive step. Verification was the step you cut when the deadline got close. We built an entire culture around that cost structure: code review as the compromise, a human reads the diff and nods, and everyone agrees to call that verified. We all knew it was a proxy. Real verification, where someone tries to break the thing in an environment that looks like production, was too expensive to do every time.

Then production got cheap. An agent writes a feature in minutes for a few dollars. And nobody rebudgeted for what that does to the next step in the line: the moment code is free, the human reading it becomes the slowest stage in the pipeline, and the one that catches the least. You can read one diff with care. You can’t read fifty a day, and the one dangerous line doesn’t announce itself.

So the cost didn’t disappear. It moved downstream to verification. Everything that follows is a consequence of that.

Hardware already did this

Chip design made exactly this transition decades ago. Writing the RTL, the code that describes the chip, is a minority of the effort. Verification is the majority, with dedicated engineers, simulated environments and formal methods, because a defect that ships costs a new mask set: millions of dollars and months of delay. Once the design step became cheap relative to a shipped bug, the industry rebuilt its org chart around checking.

Software is at that point now and hasn’t done the reorg. Most engineering budgets still look like it’s 2015: spend on typing, economize on the environments where you’d find out whether what was typed works.

What verification means when nobody reads

If the human diff is out, what replaces it? Three things, and none of them is a new idea. They just used to be too expensive.

Run it, don’t read it. A reviewer that executes attack payloads against a filter finds more than one that reads the filter. A reviewer that reproduces a shutdown bug with stub processes finds more than one that reasons about signal handling. Reading is a prediction about behavior. Running is the behavior.

Isolate the reviewer from the author. The agent that wrote the code is the wrong party to ask whether it’s done. It shares every blind spot it had while writing. Verification has to run in a fresh context that never saw the author’s reasoning, ideally a different model from a different vendor. Same model, fresh context, is the affordable version. Different vendor is the correct version.

Decide what still gets read. Behavioral testing, however brutal, finds behavioral bugs. It does not find the float holding money, the migration that quietly drops a column, the audit table that overwrites its own history. Those are structure bugs. They live in data models, and they wait. Someone has to decide that this table, this interface, this migration gets a close human look. That decision is the architect’s job now, and it is not optional. What’s optional is reading everything.

The bug no validator can see

Here is the thing: there’s a class of failure the whole stack above is blind to. The behavior is correct. The backend is correct. Security review comes back clean. And the system still does something nobody wanted, because it does exactly what the spec says and the spec doesn’t say what anyone meant.

Every reviewer in the pipeline checks code against the specification. Nothing checks the specification against the intent, except a human’s model of what the system is for. That model is the only thing that catches this class of bug. So where did it come from before?

It came from writing the code. Nobody ever budgeted for building a mental model of the system; you got it free, as a byproduct of production. Now production is free and the byproduct is gone. That’s a third cost that moved, and it’s the one nobody has noticed, because it never had a line item. Verification got expensive, but at least everyone knows what testing is. Keeping an accurate model of a system you didn’t write got expensive too, and most teams don’t have a word for it.

The reflex answer is documentation, and it’s half right. Documentation was already the lie in the old world; it went stale a week after it was written. Documentation an agent writes fails differently. It reads just as confident when it’s wrong as when it’s right. Reading it carefully doesn’t help. A careful reader still can’t tell a plausible false claim from a true one without checking it against the system, and nobody has time to check. So the move isn’t reading harder. It’s making documentation checkable: claims written as testable statements that the reviewer actually exercises. Documentation you can’t test is documentation you can’t trust.

That closes the gap between the docs and the code. It does nothing for the gap between the docs and the intent. That one is still held by a person, and when you no longer write anything there’s one way to keep it: interrogation instead of authorship. You keep your model current by arguing with something that has read all of the code, about what it does and why, until the requirement you’re about to sign off matches what you actually meant. That’s hours, not minutes. It’s the part of the job that used to happen with your hands on the keyboard, and it now has to be done on purpose, with time nobody has budgeted for it.

Which leads to a constraint on the system itself. If the model has to live in the head of someone who doesn’t read the code, the system has to be legible at the level that person still reads: interfaces, data model, requirements. Architecture that fits in a head stops being a style preference. It becomes the precondition for verifying anything at all.

What six months of my own data says

I run an orchestration tool I built, Shipper, that applies exactly this model to my own projects: an agent writes, an isolated agent tries to break it, a bounded retry loop runs between them, and I set the requirements and make the calls that are expensive to reverse. Sixteen repositories, 1,644 tasks, May to October 2026. The point of the numbers isn’t the tool. It’s what they say about the shape of the cost.

Of 1,519 tasks that reached a validator, 286 (18.8%) were rejected on substance at least once. All but nine eventually merged. The reviewer accounts for roughly 28% of model spend, against a mean of about $7 per task.

The catches worth naming: a per-user uniqueness change that still matched rows on an external ID alone, so one tenant’s import could overwrite another’s. An SVG filter that passed a namespace-prefixed script tag and an animation attribute that runs script on load. A clean-shutdown fix that turned --stop into restart under Docker’s unless-stopped. A CI change that removed a “redundant” path segment the Vault API actually requires. None of those would have survived a human skim at the end of the day, and two of them were only found because the reviewer ran something instead of reading it. On the SVG task, the last thing the reviewer rejected was a claim in the README. It tested the claim. The claim was false.

And the finding that surprised me: the biggest rejection category was not bugs. It was scope. The author did something other than what was asked, or more than what was asked, more often than it got the logic wrong. Which means the lever that matters most sits upstream of the code, in the requirement, and the reviewer’s main job is holding the author to it.

If I’m being honest, the first thing that surfaced when I pulled those numbers was a structure bug in my own audit trail. The findings table overwrote each failure with the subsequent pass, so the record of what had been caught was being erased by the act of fixing it. Hundreds of browser-driven test runs would never have found that.

One afternoon

I didn’t leave that bug there. The afternoon I found it, I had the system fix it, and the sequence shows where the human actually sits now.

An investigator agent read the code, found three deletion paths where I’d assumed one, discovered that a docstring promising a fallback audit log was false against 2,199 empty rows, and drafted a requirement doc with testable acceptance criteria. I reviewed the doc and changed three things: the archiving mechanism had a race under concurrent writes, which I replaced with a delete-and-return pattern; an access-control question that had crept in was its own can of worms, so it got its own issue; one deferred decision was recorded instead of silently resolved. A developer agent built it in six minutes. An isolated validator confirmed every acceptance criterion mapped to a named test. It merged itself and deployed.

Then the system found two more faults, one in itself and one in me. The code merged before the requirement doc it was built from, because the agent that wrote the issue hadn’t followed its own procedure for declaring the dependency. And the investigator, asked to confirm the deploy, discovered it couldn’t read the table it had just specified: when I provisioned its database role by hand months ago, I’d granted access to the tables that existed and never set the default for tables that didn’t yet. Every migration since had been invisible to it. Both got the same treatment: spec, review, build, verify. The second spec’s own task was made to depend on its own document, and sat parked for fifteen minutes until I merged the doc, then released itself seven seconds later.

Across the afternoon I made four decisions, merged two documents, and fixed my own role grants by hand. Everything else was reading, and most of the reading was of requirements and findings, not code. It would flatter me to call those four decisions the hard part. They were easy, because the system that proposed them was built, over hundreds of earlier decisions, to deliver proposals with the evidence attached. The hard part was done months ago, in the shape of the loop. The whole afternoon started because I decided one table deserved a close read.

Verification is a budget, and the environment is the budget

None of the above runs on a laptop. Running instead of reading needs somewhere to run: an integration environment that resembles production, data that looks like real data, the compute to execute a thousand end-to-end passes instead of one. Those are precisely the things engineering organizations have spent twenty years cutting, because for twenty years they were the optional step.

Where that environment doesn’t exist, the only check left is a person reading the diff. The human is still the quality gate, and now the human is also the bottleneck, because the one thing that didn’t get faster is how many lines a careful reader can hold in their head per day. An organization that buys agents and skips the environment has not automated anything. It has moved the queue from the keyboard to the reviewer’s eyes.

The same organizations then buy cheaper models to save on the step that was already cheap. That’s the error. They’re saving on the step that got cheap and starving the step that got expensive, because the budget still has the old shape.

I’m not exempt. My design calls for a second vendor on the reviewing side, and the brief period it ran that way is where the cross-tenant write above was caught. Then the pricing made it uneconomical for one person, so I run same-model, isolated-context, and I spend 28% on verification when I’d spend more if the second model cost what the first does. Verification is a budget. Blast radius should set it. Mine is small on my own projects, and my standard is looser there than on anything other people depend on, for exactly that reason.

What the job is now

There is no way back. Writing code by hand is already a niche skill. But “AI does the work” is the wrong replacement, and I say that as someone who hasn’t typed a function in months.

The developer doesn’t get cheaper. The developer’s time moves. The hours that went into typing and reviewing diffs go to architecture, to reviewing specs before anything is built, and to building the automation that does the verifying. That’s where the skill was always most valuable. It was just never free to go there.

What replaced hand-coding is a verification discipline most teams haven’t built: run it in a real environment, with a reviewer that didn’t write it, keep the record of what it found, hold a model of the system you can defend, and decide, deliberately, which few places a human still reads closely.

Produce cheap. Test brutally. And know which five things to look at yourself. That last part is the whole job.