The Diagnosis Is Right
Atomic Object published a piece last month arguing that with AI agents, attention is the new bottleneck. Agents made execution cheap. You can fire off four parallel coding agents before your coffee cools. What you can’t do is review four streams of output at once, hold the context of each in your head, and catch the one that quietly wrote a migration that drops a column.
The diagnosis is correct. Simon Willison described running four parallel agents and being wiped out by 11am — not because the tools failed, but because he became the rate limiter. Michael Novati made the same point from a different angle: AI removed the production bottleneck and revealed the real one underneath — the human system that surrounds production. Everyone circling this problem is seeing the same thing. Execution went to zero and human attention became the scarce resource.
So the diagnosis holds. The prescription is where it falls apart.
The “Type Faster” Answer
Atomic Object’s advice is all personal discipline. Automate trivial decisions. Plan for cognitive load. Take deliberate breaks. Budget your attention like a finite resource. Good advice for a person. Useless as a system.
We’ve seen this exact move before. When execution was the bottleneck — when developers spent their day typing, compiling, catching their own syntax errors — nobody’s answer was “type faster.” Nobody wrote a productivity blog telling engineers to be more disciplined about their keystrokes. We built compilers so you didn’t hand-check types. We built linters so nobody argued about a missing semicolon. We built CI so the machine ran the test suite at 2am and told you which commit broke it.
The bottleneck moved and we answered with infrastructure, not willpower. Telling a developer in 1998 to concentrate harder on avoiding null-pointer bugs would have been absurd. Telling a developer in 2026 to budget their attention better is the same absurdity wearing new clothes.
Discipline doesn’t scale. Infrastructure does. If your plan for the attention bottleneck is “I’ll be more focused,” you’ve already lost, because the failure mode of human attention isn’t insufficient effort — it’s that there’s a finite amount of it and agents produce work faster than any amount of focus can absorb.
Engineer the Bottleneck Instead
Here’s the reframe. Attention is a resource your system spends on your behalf. Most systems spend it wastefully — they make a human look at everything. The job is to build the parts that spend it carefully, the same way a good compiler spends your debugging time carefully by pointing at line 47 instead of making you read the whole file.
Four pieces do most of the work.
Verification gates so humans review exceptions, not everything. The default agent workflow asks you to eyeball every output. That’s the waste. Instead, have the agent verify its own work and only surface what it can’t confirm. My content pipeline ships blog posts across five channels. After it publishes, a verifyPublishedPost() step re-fetches the committed markdown and checks for the two failures that actually happened to me — a missing feature image, and a leading H1 that double-rendered the title. If it finds one, it fires a 🚨 line into my notification channel. If everything’s clean, I hear nothing. I went from reading every published post to reading only the broken ones. That’s not discipline. That’s a gate.
Structured escalation so one line beats a log stream. Uptime monitoring is the canonical trap. You can watch a dashboard, or you can read logs, or you can have every alert route to a single channel with a single flagged line: what broke, where, since when. I don’t read my nightly job logs. They write to disk. If a job fails, one message arrives. The difference between “check the logs” and “here is the one thing that needs you” is the difference between spending attention and saving it.
Trust tiers per task class. Not all work deserves the same scrutiny, and pretending it does is how you burn attention on things that don’t need it. Low-stakes work ships on green checks — my content pipeline’s Tier 1 curated shares go out on a passing lint gate, no human in the loop. High-stakes work queues for review. The on-demand blog publisher treats my explicit request as the approval and ships without a gate, because I asked for it. The cron pipeline that drafts on its own routes through an approval message first. Same infrastructure, different trust tier, matched to the blast radius of being wrong.
Decision logs so the same call never reaches a human twice. This is the one people skip, and it’s the one that compounds. Every time you make a judgment call for an agent, write it down where the agent reads it. My project instructions carry a running list of hard-won lessons — never hand-author markdown into the blog repo, opt into Instagram explicitly because the publishing API returns false-success statuses, strip any leading body H1 unconditionally. Each of those is a decision I made exactly once. The agent now makes it every time without me. A decision log is a cache for judgment. Without it, you re-answer the same question forever, which is the most expensive way there is to spend attention.
The Objection Worth Taking Seriously
The honest counterargument: infrastructure has a build cost, and discipline is free today. Writing a self-verification step, wiring escalation, defining trust tiers — that’s real work, and for a solo developer running one agent occasionally, personal focus genuinely is cheaper. Atomic Object isn’t wrong that a human should also automate their own trivial decisions and take breaks.
But that’s a bet on the problem staying small, and it won’t. The whole premise is that agents multiply output. The developer running one agent this month runs six next quarter. Discipline that works at one stream collapses at six — that’s the entire bottleneck being described. You pay the infrastructure cost once and it holds as you scale. You pay the discipline cost every single day, and it fails exactly when the load gets heavy enough to matter. Build the gate before you need it, because the moment you need it you won’t have attention left to build it.
What Actually Separates the Winners
The framing that treats attention as a personal-productivity problem is going to age like every other “work smarter” answer to a structural constraint. It puts the burden on the operator to be superhuman, when the whole point of the last forty years of tooling was to stop requiring humans to be superhuman.
The people who win with agents won’t be the ones with the most discipline about their attention. Discipline is a fixed, small, human quantity, and the workload is about to be neither fixed nor small. The winners will be the ones whose systems spend their attention the least — whose agents verify themselves, escalate the one thing that matters, ship low-stakes work without asking, and never bring the same decision back a second time.
Attention is the new bottleneck. So engineer it like one. We didn’t beat the execution bottleneck by typing faster, and we won’t beat this one by concentrating harder.