We Don't Trust AI's Code. We Also Don't Read It.

A few weeks ago I committed code I hadn't read.

Not skimmed-and-trusted. Not read-the-diff-and-missed-a-line. I mean I described what I wanted, watched a few hundred lines appear, scrolled to the bottom, saw that it looked right — clean names, consistent style, nothing obviously off — and committed. The tests were green. It looked read. So I treated "looks read" as "is read," and moved on.

My first reaction, when it landed on me later, was guilt. The familiar kind: you know better, you've built review systems, and you rubber-stamped your own output like a junior on a deadline.

Then I caught the guilt and put it down, because guilt was the wrong reaction. It was treating a signal as a personal failing. And the moment I stopped reading it as shame and started reading it as data, the whole thing got more interesting.

The paradox isn't personal

Here's why I don't think this was just me having a weak afternoon.

A recent survey put it about as starkly as a number can: 95% of developers say they don't trust AI-generated code — and only 48% consistently review it before it ships. Stack Overflow's latest numbers point the same way: distrust of AI output jumped from 31% to 46% in a single year, even as adoption climbed past 84%.

Sit with that for a second. We don't trust the code. We use it anyway. And then we don't read the thing we don't trust.

That's not a contradiction one tired engineer fell into. That's an entire industry doing the same supposedly-irrational thing at once. And when everyone independently arrives at the same broken behavior, "everyone lacks discipline" is almost never the answer. It's the wrong layer. The behavior is a symptom. Something underneath it moved, and our habits are still standing where the ground used to be.

What actually moved

For most of the history of this job, writing code was the work. It was also, quietly, where trust came from. You didn't trust a function because you reviewed it afterward — you trusted it because you wrote it, line by line, holding the whole thing in your head as it took shape. Understanding was a free byproduct of construction. You couldn't write it without understanding it.

Generating code dropped that cost to roughly zero. And when the cost of producing something collapses, the valuable part doesn't disappear — it moves downstream. It moved from writing to reading, judging, deciding. From producing the lines to deciding whether the lines deserve to exist.

So the gap between "I don't trust it" and "I didn't read it" isn't a lapse. It's the exact shape you'd expect when the job relocates faster than the habits do. The work is now downstream, and most of us are still standing upstream, where writing used to be, wondering why the old instinct — I made it, so I know it — doesn't fire anymore.

It doesn't fire because we didn't make it. We ordered it.

Reading is harder than writing ever was

The uncomfortable part is that the new center of the job is genuinely harder than the old one, and nothing about it feels that way. Four reasons it bites:

Writing handed you trust for free. Reading doesn't. When you wrote a thing, understanding came bundled with construction at no extra charge. Reading unbundles them. You can finish reading a function and still not feel it the way you'd feel one you'd built — so the brain, reasonably, looks for a shortcut.

AI code looks reviewed. This is the trap that got me. Generated code arrives fluent: tidy names, uniform structure, zero typos, the surface texture of code a careful person already cleaned up. Visual fluency impersonates correctness. Hand- written code wears its uncertainty on its face — the half-finished name, the odd spacing, the comment that says fix this. Generated code wears a finished face over unknown internals. It looks done, so we treat "done-looking" as "checked."

Dense, foreign, probably-correct code is the worst thing to read. Reviewing code that's likely fine but occasionally, subtly wrong is more tiring than writing it from scratch — and far duller. Writing got cheap. Reading costs exactly what it always did. We're spending old-price attention on a task we now do ten times as often.

Speed suppresses attention. There's a quiet inverse law here: the faster code arrives, the less of yourself you give each line. A function that took an hour to write earns an honest read. A function that took nine seconds to generate gets a nine-second glance. The supply rate sets the attention budget, and right now the supply rate is winning.

None of these are character flaws. They're properties of the new terrain. Which is the point — you don't fix terrain with willpower.

The debt nobody chose

I've written before about how this code gets made — the slot-machine pull of generate, glance, accept, repeat. This is the other half: what it leaves behind.

Classic technical debt is a decision. Someone looked at a shortcut, understood the tradeoff, and took it on purpose — I know this is hacky, I'll come back in Q3. There's an author, an intent, a thread to pull.

What accumulates when we ship code we didn't read is a different animal. Call it understanding debt. Code that works, that passed, that's in production — and that nobody on the team actually understands, including the person whose name is on the commit. There's no author to ask why like this, because no one decided like this. It seeped in. It's not a shortcut someone took; it's a gap no one knew opened.

Technical debt you can pay down, because someone knows where the bodies are. Understanding debt you have to re-derive — reverse-engineering your own codebase as if a stranger wrote it. Which, in a sense, one did.

Reading is the craft now. Treat it like one.

Here's the part I'd rather end on, because diagnosis without a way forward is just complaining with footnotes.

If the valuable act moved to reading, then reading stops being the boring tax you pay after the real work and becomes the real work. That's not a loss. It's a promotion for a skill we never named. A few things that have actually moved the needle for me:

Read it like a PR from a stranger — because it is one. The mental move that fixed the most for me was dropping the fiction that generated code is "mine." It isn't. I didn't write it; I requested it. Reviewing it with the suspicion I'd bring to an unknown contributor's first PR isn't paranoia — it's accuracy.

Run the explain-it-back test. Before code I generated goes in, I make myself say out loud what it does and why it does it that way. Not the happy path — the edge it handles, the thing it assumes, why this approach over the obvious other one. If I stall, it's not done. The stall is the understanding debt announcing itself before it ships instead of six months later.

Slow down in proportion to how fast it arrived. Counterintuitive and correct. The faster the generation, the more deliberate the read. Speed on the input side is exactly why you need friction on the output side. The two aren't in tension — one is the price of the other.

Build the muscle on purpose. Reading code well is trainable, and most of us trained the opposite skill for a decade. It's worth spending real reps reading code you didn't write and reconstructing the author's intent — the way you'd practice anything you intend to be good at, rather than assuming it'll show up when you need it.

I automate part of this reading layer in my own setup, but that's a separate post — and it's a complement to the habit, not a substitute for it. No system reads on your behalf the code you're the one accountable for.

The skill that quietly became the job

The launch-week framing of this whole era is who can produce the most, the fastest. The doom framing is who distrusts the machine the loudest. Both miss it.

This phase won't be won by the fastest writer, and it won't be won by the most theatrical skeptic. It'll be won by whoever rebuilt reading into a deliberate craft while everyone else was still optimizing the part that got automated.

We don't trust AI's code. Good — that instinct is correct. The work now is to earn the right to that distrust the only way there is:

by actually reading the thing.