The pitch for AI coding agents is that you hand off more and more of the work and let them run on autopilot. For a lot of work, that’s true. Renames, lint fixes, dependency bumps, a CRUD endpoint that looks like the other twelve. Small stakes, easy to check. I let agents run on that stuff without much thought.
But agents also free you up to take on more ambitious work, and that’s where the pitch breaks down. The short version:
Every unit of output still costs some attention. The more ambitious the work, the more attention each unit costs. So the total attention bill goes up, not down.
I can run a lot of work in parallel, up to a point. Past it, everything slows down. Not because the agents get slower, but because I do.
The ultimate nerdsnipe
My friend put a name to this when we were talking it through: agents are the ultimate nerdsnipe. If you haven’t seen it, xkcd 356 describes nerd sniping: hand an engineer a problem that’s interesting enough and they’ll drop everything to work on it. Agents do this on tap. Every idea you have is suddenly a few prompts away from real, so you start it. Then the next one. Each thread is interesting, each one is cheap to start, and each one quietly claims a slice of your attention.
Cheaper execution, bigger bill
In 1865, William Stanley Jevons noticed that more efficient steam engines didn’t make England burn less coal. It burned more, because cheaper work made new uses worth it. That’s the Jevons paradox, and agents do the same thing to execution. Writing code got cheap, so I take on work I wouldn’t have tried before. That’s the whole promise of agents. But bigger work comes with a bigger attention bill.
Working memory is the ceiling
Here’s what it feels like. I have several threads going, each with an agent doing real work, and each one needs me to remember what it’s for. Why did we pick this approach? What edge case were we worried about? What did the agent say three hours ago that I meant to come back to? Past a few threads, it turns into browser tabs you never close: all “in progress,” and I couldn’t tell you what half of them are for.
That’s working memory, and it’s small. George Miller’s famous 1956 paper put it at seven, plus or minus two items, and later work by Nelson Cowan puts it closer to four. Every open thread takes up slots: its goal, its open questions, the decisions still pending. Complex work takes more slots per thread. That’s why ten threads of trivial work feel fine, and three threads of hard work make me lose the plot.
Switching between projects makes it worse. Two threads in the same codebase share most of their context. Two threads in different projects share almost none. Every switch evicts one project from your head and loads another: a different domain, different conventions, different reasons for why things are the way they are. I keep a spine repo over my projects to make that reload cheap for the agents, but nothing makes it cheap for me. Gerald Weinberg’s rule of thumb, decades before agents, was that each extra project you juggle costs you something like 20% of your time in switching. Agents make switching faster, which sounds like a feature. It isn’t. You switch more often, and you pay the reload every time.
Why ambitious work eats attention
You can only trust what you can check. Autopilot works when a mistake is cheap or checking is cheap. Ambitious work is nearly the opposite by definition. It’s new, the stakes are higher, and there’s no test that tells you whether it’s right. If a test for “right” already existed, the work wouldn’t be ambitious. I wrote about this in The Verification Gap: the agent can write the tests, but deciding what “correct” means is still on you.
Typing speed used to ration your decisions. Every diff contains dozens of small decisions: names, boundaries, error handling, the shape of the data. When I wrote code by hand, those decisions showed up one at a time, at the speed I could type. Now they show up at the speed an agent writes, and each one is a decision I either make or hand over without looking.
Defaults pile up into a design nobody chose. Every choice an agent makes on its own is reasonable. On a small task that’s fine. On ambitious work, the pile of reasonable choices is the architecture. I’ve started calling this comprehension debt: you own a system you don’t understand. Like tech debt, it comes due at the worst possible time, usually in the middle of an incident.
You are the part that can’t run in parallel. Amdahl’s law says the part of a job that can’t be parallelized limits the total speedup. My judgment is that part. On small tasks very little has to go through me. On ambitious work almost everything does at some point, and the ceiling drops fast. Fred Brooks made the same point about people in The Mythical Man-Month: adding more workers adds coordination cost, and someone has to do the coordinating. With agents, that someone is me.
The hard parts never left
None of this is new. Amdahl published his law in 1967. Brooks wrote The Mythical Man-Month in 1975. Miller, Weinberg and the rest were writing decades before anyone typed a prompt. Working with agents is software engineering from first principles, wearing a different hat.
Brooks also wrote No Silver Bullet, which splits software difficulty into two kinds. Accidental complexity is the friction of our tools: typing, syntax, boilerplate, plumbing. Essential complexity is the problem itself: deciding what to build, designing it, and knowing it’s right. Agents are the best tool we’ve ever had against accidental complexity. They barely touch the essential kind. Shrink the accidental part and the essential part is what’s left, and it lands on you.
Lisanne Bainbridge saw the same pattern in 1983 in Ironies of Automation: automation takes the easy parts and leaves the human the hard ones. Real autopilot flies the cruise. The pilot still handles takeoff, landing and anything unexpected.
The hardest part is still the oldest one: working on the right thing at the right time. My approach is to ruthlessly prioritize what’s important and give side agents the work that doesn’t need much brain power. Watching Sentry after a deploy. Tailing CloudWatch logs. Keeping an eye on RDS performance metrics. Until the monitoring agent finds a spike in errors or a query that’s suddenly slow, and now it’s an investigation pulling my full attention away from whatever I’d decided mattered. That’s the nerdsnipe again, except this time it came looking for me.
And the decision fatigue is real now. Every agent turn ends with a question for me. Approve this plan? Option A or B? Is this diff right? Keep going? Each one is small. Across a day of parallel threads they add up to hundreds, and my judgment on the last one is not as good as on the first. Agents make it easy to start things. They do nothing to help you decide what deserves you.
What I do about it
None of this is an argument against agents. It’s an argument for spending attention on purpose.
- Sort work by stakes and checkability. Low stakes and easy to check goes on autopilot, without guilt. High stakes or hard to check gets me, not just an agent.
- Run breadth in parallel, keep depth serial. Many agents on independent, low-stakes tasks is fine. On the ambitious thing, I run one or two threads and I stay with them.
- Spend attention on decisions, not keystrokes. Plans, interfaces, data models, invariants, and anything that’s hard to undo. I review the plan more carefully than the diff.
- Turn attention into checks. This is the only way I know to move hard work toward autopilot: write my judgment down as something runnable. It costs attention up front, but I only pay it once.
- Park threads on purpose. If I can’t say what a thread is for, it either gets my attention now or it gets parked deliberately. An open thread I’m not attending to isn’t progress. It’s a liability I’ve forgotten about.
- Treat my attention as the work-in-progress limit. Not the number of agents I can spawn.
“But the agents will get better”
They will, and more work will become safe to hand off. But ambition rises right alongside them, and your attention moves with the hard edge of your work. That’s the Jevons paradox again.
And no agent can take the understanding part, however good it gets. If you care about understanding what you’re building, attention isn’t overhead to cut. It’s the whole point. You can’t send someone to the gym for you.
If all you want is output, sure, let it run. But if you care about understanding anything, or about doing something that matters, agents don’t free up your attention. They raise the stakes on where you spend it.