AI Writes the Code. You're the One Burning Out.

Coding agents ship code faster than any human ever could. And yet developers keep saying the same strange thing: I’m more tired than I used to be. Automation was supposed to reduce the load. Instead, something got heavier. Here’s what I think is actually going on.

One caveat up front. This isn’t a roundup of a hot debate raging on Hacker News this week. It’s a structural argument about a pattern that keeps showing up across teams, and it’s my read on it rather than a summary of anyone else’s. Take it in that spirit.

The Loop Was Built for a Slower World

Human-in-the-loop means inserting human judgment into an automated system. The machine proposes, a person checks — either before the action fires or right after.

The logic is airtight. AI gets things wrong. So a human carries final responsibility. Think seatbelt.

The trouble isn’t the seatbelt. It’s how often you have to buckle it. Once a day, that’s a safety device. Once a minute, unbuckling and rebuckling, hands never leaving the latch — that’s not safety equipment anymore. That’s a stress position.

The Asymmetry Nobody Priced In

Everything downstream comes from one asymmetry.

An agent generates code dozens of times faster than a person writes it. But reading that code, understanding it, and judging it still runs at human speed. Generation happens at machine tempo. Verification happens at meat tempo.

So the bottleneck relocates. It lands squarely on you. Where the job used to be mostly writing code, now it’s mostly reading code somebody else wrote.

And here’s the part that gets underestimated: reviewing is cognitively more expensive than writing. When I write code, the context already lives in my head. When I review yours, I have to rebuild that context from scratch before I can even start evaluating. Now make the author an agent that doesn’t share your mental model, your history with the codebase, or your reasons for anything. The reconstruction cost goes up, not down.

Automation Complacency, and the Rubber Stamp

Human factors researchers have a name for this, and it’s decades old: automation complacency. When an automated system works reliably most of the time, the monitor stops monitoring.

Aviation proved this out over and over. Pilots who trust the autopilot for hours are measurably slower to notice when the autopilot starts doing something wrong. The system’s reliability is what erodes the vigilance that’s supposed to catch its failures.

Coding agents run the exact same play. The first few diffs, you read every line. Then twenty consecutive PRs come back clean. What happens on the twenty-first? You scroll. You approve. You move on.

That’s the rubber stamp. On paper, a human reviewed it. In practice, nobody looked.

Now the cruel part. The safety mechanism has quietly failed, but the liability hasn’t moved. When something breaks in prod, the question is still “why did you approve this?” The system pushed changes at you faster than any human could meaningfully inspect them, and then held you accountable for inspecting them. You get the responsibility without the capacity. That’s not a safety design. That’s a liability sink with a person at the bottom of it.

It’s Decision Fatigue, Not Workload

The exhaustion isn’t just volume. It’s the kind of work.

Review is an unbroken chain of decisions. Approve or don’t. Is this approach right or subtly wrong. Is the missing error handling deliberate or an oversight. Every one of those is a judgment call, and they arrive back to back with no recovery time between them.

Psychologists call this decision fatigue: make enough judgments in a row and the capacity to judge depletes. And when a depleted person hits a decision, what’s the default they fall back on? Usually the path of least resistance. Usually approve.

Which makes the whole thing a loop that feeds itself. More review load, more fatigue, sloppier reads, more incidents, tighter review requirements, more fatigue. The remedy accelerates the disease.

There’s one more layer, and it might matter most. The joy of building disappears. Most developers got into this because making things is fun. Spend your entire day inspecting output you didn’t create and the job quietly changes profession — from craft to audit. Burnout arrives faster from meaninglessness than from workload. Volume you can survive. Pointlessness you can’t.

What Actually Helps

No clean answers here. But there are directions.

Cut the number of checkpoints. Stop inserting a human at every stage. Put them only where the action is irreversible: deploys, schema migrations, billing logic, anything touching auth. Everything else gets caught by tests and rollback. If a mistake is cheap to undo, it isn’t a thing to review — it’s a thing to run.

Make review reviewable. Throwing a 500-line diff at a person guarantees they see nothing. Force the agent to lead with what it changed, why, and where it thinks the risk lives. The value isn’t the summary. It’s that it narrows where a human has to spend their limited attention.

Tier your trust. There’s no reason a test-fixture addition and a change to session handling get the same scrutiny. Same-intensity review for everything means real intensity for nothing.

Recognize this as a design problem, not a discipline problem. “Be more careful” is not a fix. Sustained human attention has hard physiological limits, well documented long before any of us had a coding agent. You don’t out-willpower a physiological limit. You route around it with system design — or you don’t, and you call it a personal failing when it breaks.

The Question Worth Sitting With

Human-in-the-loop was a good idea. It just wasn’t designed for a world where the machine emits a reviewable artifact every few seconds. The belief that adding a person makes a system safe only holds while that person can actually see.

So the real question isn’t whether to keep humans in the loop. It’s this: do we make people look at everything, or only at what matters?

Which one is your team doing? And when you hit approve this afternoon — will you be looking at the screen?