Managing Decision Fatigue in AI Driven Work

Let’s talk about an age-old developer problem: getting interrupted mid-task. If you’ve been doing this job for more than a few years you know the feeling — you’re deep in a problem, holding half the codebase in your head, and someone taps you on the shoulder. Poof. Gone. Previous research famously pegged the recovery time at around 23 minutes per interruption, which honestly sounds about right to me.

You’d think AI coding tools would have improved this. Hand the grunt work to an agent, protect your focus for the hard stuff, right?

Here’s what I’ve noticed instead: the interruptions didn’t go away, they changed source. It used to be Slack, meetings, or the classic shoulder tap. Now it’s you. Developers can become their own worst enemies, and this can lead to burnout and delegation of important decisions to AI, unless it is recognised early and carefully managed.

The prompt-and-wait gap

The problem lives in the gap between sending a prompt and reading what comes back. Ten seconds, ninety seconds, sometimes a few minutes. It’s a weird dead zone — too short to start anything meaningful, and sitting there staring at a spinning icon just feels wasteful.

So what do we do? Check Slack. Glance at email. Or the really tempting one: open another terminal and kick off a second agent on something completely unrelated. I mean, why not, right? The first agent is busy, you’re just sitting there, might as well be productive.

Except none of this registers as an interruption, because you did it to yourself. There was no notification, no shoulder tap. It feels like using dead time well. But research following developers around in their actual work found they rate their most productive days as the ones with the fewest context switches. Not the busiest days. The calmest ones. Running three parallel agent sessions feels productive while matching the exact pattern developers themselves describe as a bad day.

Interestingly, self-interruption isn’t even new. A paper from back in 2005 found that roughly half of workplace interruptions were self-initiated, and they interestingly found that external interruptions are more expensive than interrupting yourself. The issue is we’ve now got tooling around a gap that invites it, dozens of times a day.

The defences we spent fifteen years building don’t work on this. Do-not-disturb, closed door, snoozed notifications — all of that intercepts things coming from outside. There’s no setting that stops you from alt-tabbing during an agent run.

Your real job now is making decisions

Here’s the bit I think maybe hasn’t sunk in for some people: the role has shifted. This post from Mark Cassidy is excellent. We’re not really programmers anymore, not in the keystrokes sense. Most of the day is now judgement calls — what should the agent build, is what it built actually right, what’s next. The typing was never the bottleneck. The deciding is.

And decision-making ability is finite. The exact mechanism is still argued about in the research (the original “ego depletion” theory has taken some hits in replication), but the practical pattern is well established: decision quality drops as the day wears on, and tired people start accepting defaults without checking them. Judges, doctors, parole boards — same story everywhere.

Now here’s the kicker. Deciding whether to check Slack during an agent’s think-time is a decision. A tiny one, but it comes out of the same budget as “does this refactor actually do what I asked for?” Burn the budget on rubbish micro-decisions all morning and there’s less left for the calls that actually matter. That’s the real cost of the self-interruption habit — it’s not just scattered attention, it’s spending your scarcest resource on questions that weren’t worth asking.

The burnout loop, and why it makes you a worse reviewer

This has a mental health angle too, and it’s not a small one. Frequent context switching has been linked to burnout in knowledge workers independent of actual workload — and it’s a loop, because burnout then eats the cognitive capacity you need to manage your tasks well, which leads to more fragmentation. Round and round.

The part that should worry you professionally: fatigue changes how you review agent output. There’s a whole body of research on automation bias showing that people under higher cognitive load lean harder on automated output and verify less, because accepting is cheaper than checking. Sound familiar? It’s 4:30pm, you’ve been ping-ponging between four agent threads since lunch, a diff comes back, it looks fine… approve. Prompt fatigue is real, and a prompt-fatigued developer is exactly the one who blindly accepts the model’s work.

That’s when this stops being a personal energy problem and becomes a delivery problem. The code most likely to ship without a proper review is the code produced in exactly the state this habit creates.

What I actually do about it

None of this means ditching the agents. It means being deliberate about the gap. What’s been working for me:

• Stay in the same problem space. If the gap tempts you to switch, switch to something related to what you’re already on. Don’t start an unrelated deep-work session — that’s a full context switch dressed up as productivity. Short shallow stuff (a one-line Slack reply, approving a small PR) is fine filler. A fresh design problem is not.
• Write the tangent down, don’t chase it. Agent output constantly surfaces related tasks and “oh we should also…” moments. Jot them in a notes file and keep moving. They’ll still be there in twenty minutes.
• Batch the review. Read the agent’s output in one proper pass rather than peeking at progress every fifteen seconds. The peeking is just self-interruption with extra steps.
• Cap concurrent sessions. One, maybe two unrelated threads max. Every extra thread is another mental model you have to rebuild on each switch.
• Delegate the thinking, keep the verifying. It’s genuinely fine to hand real thinking to an agent — scoping, first-pass design, exploratory refactors. Feel safe doing that, it’s the whole point. But it only works if you’ve protected enough decision-making capacity to properly check what comes back. If you notice fatigue doing the approving instead of you, that’s your cue to stop for the day, not to push through another three diffs.

The tools changed, the fundamentals didn’t. Flow state still needs protecting — it’s just that the thing you’re protecting it from is now sitting in your own chair.

Make your own mental health your number one priority and you’ll hopefully find that your work life balance will improve.