AI Agent Decision Fatigue: 200 Judgment Calls a Day

The agent finishes in nine seconds. I spend the next four minutes deciding whether it's right.

That ratio is the whole story.

Every coding session has the same shape now. I describe what I want. Something produces a complete, plausible, well-formatted answer faster than I can read the first paragraph of it. Then everything stops and waits for me. Not for my expertise. For my verdict.

Agents can run the entire development cycle — write the code, write the tests, write the docs, open the PR, deploy it. What they cannot do is decide. So the work didn't disappear. It got distilled into a few hundred small judgment calls a day, and that is a completely different job than the one I trained for.

None of Them Are Hard

Is this actually done, or does it just say done. Is that test asserting behavior or asserting the mock. Is this the right file for this. Is that abstraction earned or is it decoration. Did it fix the bug or route around it. Is this failing check a real problem or a bad check. It refactored four other things while it was in there — do I want that. One commit or three. Do I read the diff or trust the summary.

Not one of those is difficult. I can answer any of them in a few seconds.

That's exactly what makes them expensive. Nothing about a single call feels like it deserves attention, so you never budget for it. Then it's six in the evening, the commit log says you shipped an enormous amount, you are hollowed out, and you cannot point at one hard thing you did all day.

They All Look the Same When They Arrive

This is the part that actually costs.

Out of a few hundred calls in a day, maybe three matter. One of them might be genuinely dangerous. And there's no way to tell which from the outside, because the dangerous one shows up wearing the same clothes as a formatting change. Small diff. Sensible commit message. Green tests.

The worst thing I've ever caught arrived inside a completely correct bug fix, as a tidy little improvement any reviewer on earth would have waved through. The code was right. The tests passed. Nothing about it asked for a second look.

So you can't triage by appearance. You have to bring real attention to all of them, because the one time you don't is the one that counts. That's the tax. Not the deciding — the not knowing which of the decisions are the decisions.

Reading Is Slower Than Writing Now

For thirty years the bottleneck was production. Typing was slow, thinking was slow, and checking your own work was the cheap part — you'd just built the thing, so the model of it was already in your head.

That's inverted. Production is free. Verification is not, and it never will be, because understanding code you didn't write has a floor set by human reading speed. Nothing in the last three years has moved that floor by a single percent.

And the agent picks the moment. It hits a fork, stops, and asks. You don't get to finish your thought first. Every judgment call arrives as an interrupt, which is why context switching became the real bottleneck the moment the typing went away.

What It Degrades Into

You don't fail by making a bad call. You fail by quietly ceasing to make them.

Somewhere around the hundredth approval of the week, I notice I'm not reading diffs anymore. I'm reading the agent's summary of the diff and checking it against what I already expected to see. That isn't review. That's a vibe check on a self-report.

It's the most natural thing in the world. Nobody decides to lower the bar. You just find out later that it's lower — usually when you go looking for something else and find what you approved. That's the confidence-without-competence gap pointed back at me instead of at the model.

Nobody Talks About This Fatigue

It comes out of the same tank as everything else. The attention I spend on whether an abstraction is premature is drawn from the same account as whether a market is real, which is why this kind of depletion hits founders harder than the hours on the calendar suggest.

And it's worse than ordinary tired, because it's disguised as leverage. It looks like output. The dashboard is green, the velocity is absurd, and you feel like you've been hit by a truck.

The pitch is that agents eliminate the work. What they actually deleted is the half I found restful. Writing code was never the hard part — it just took long enough to feel like the job. What's left is the part I can't hand to anything, arriving at machine speed, all day, dressed up as progress.

If you end one of these days wrecked, having written nothing yourself — you did the expensive part.