Your brain is the biggest bottleneck in AI productivity

Last Tuesday I had three Claude Code sessions running at once. One was refactoring the build script for this site. One was writing test coverage for a data pipeline. The third was batch-editing TMDL files, because a semantic model with forty tables deserves better than me doing find-and-replace by hand. All three finished within a minute of each other. Three terminals of green text, then silence. The machines were done. They were waiting for me.

I reviewed the first diff the way I review any diff: one hunk at a time, holding each change against what I know about the surrounding code. It took about twenty minutes. Sessions two and three sat idle the whole time. Somewhere in a data centre, hardware that can produce a thousand words a minute waited while one man in Malaysia reread line 41, unsure about an edge case.

That afternoon is the whole problem in miniature. Generation is now cheap, parallel and nearly instant. Comprehension, judgement and verification still run on one brain, serially, at biological speed, and they get worse as the day goes on. The constraint on AI productivity has moved. It lives in the reader now.

The constraint always moves

Computing history is a record of bottlenecks being relocated. Compilers removed hand-assembly and exposed design as the slow part. Spreadsheets removed arithmetic and exposed the harder question of what to model. Stack Overflow removed the hunt for an answer and exposed the skill of knowing which answer to trust. Each tool made one activity so cheap that the activity behind it became the new constraint.

There’s a name for the general case: Amdahl’s law. Speed up one part of a system and the overall gain is capped by the parts you left alone. Large language models sped up production, spectacularly. Everything left alone is in your skull.

The arithmetic

The best estimate of adult silent reading speed comes from a 2019 meta-analysis by Marc Brysbaert, covering 190 studies and roughly 18,600 people: 238 words per minute for non-fiction. That’s reading, where the words only have to pass through you. Reviewing runs slower. Checking a claim against a source, or a diff against the rest of a codebase, means stopping, holding two things in your head at once, and deciding. Nobody has clocked that anywhere near 238.

A model can hand you 1,500 words in well under a minute. At reading speed alone, that’s more than six minutes of your attention, and judging it properly might be twenty. Every token the model generates is a claim on that attention, and tokens are effectively free now. Run three sessions at once and the thing that triples is the queue at the only checkpoint, and the checkpoint reads at the same speed it did in 1999.

Almost right, but not quite

Developers have already run this experiment at scale. Stack Overflow’s 2025 survey, with about 49,000 respondents, found the most cited frustration with AI tools, at 66%, was dealing with solutions that are “almost right, but not quite”. Another 45% said debugging AI-generated code is more time-consuming. More developers now actively distrust the accuracy of AI output (46%) than trust it (33%). The tools are being used more than ever and believed less than ever. That’s how you treat a fast colleague with a plausible manner and a patchy record.

Almost right is the expensive kind of wrong. Obviously broken output rejects itself. Output that compiles, reads well and contains one quiet error demands the full careful read from someone who knows enough to catch it. I’ve written before about models that agree with you while being wrong; plausibility is what these systems are optimised for, and plausibility is exactly the property that makes checking slow.

A CHI 2025 paper from Microsoft Research and Carnegie Mellon, built on a survey of 319 knowledge workers, mapped where the effort goes: generative AI shifts work from information gathering to information verification, from problem-solving to response integration, from doing tasks to supervising them. Supervising sounds like the easy seat. Lisanne Bainbridge explained back in 1983 why that seat is hot: automate the routine work and the human keeps only the exceptions, while losing the daily practice that made them any good at exceptions.

Cognitive debt

The uncomfortable part of that CHI paper is the confidence finding. Workers who trusted the AI more reported applying less critical thinking to its output. Workers confident in their own skills applied more, and paid for it in effort. The tool invites you to spend less of the exact resource that limits it.

There’s early neuroscience pointing the same way, and it deserves its caveats up front. An MIT Media Lab team led by Nataliya Kosmyna ran an EEG study of essay writing across three groups: LLM-assisted, search-engine-assisted and unaided. Fifty-four participants took part, only 18 completed the final crossover session, and the results sit in a preprint the authors themselves call preliminary. Within those limits, the LLM group showed the weakest neural connectivity, struggled most to quote their own essays afterwards, and reported the lowest sense of ownership over what they’d written. The authors named the pattern cognitive debt, then spent months asking journalists to stop translating it as brain rot. A small study saying a modest thing: offload the thinking and less of it sticks.

That matters for the bottleneck maths. If judgement is the constraint, any usage pattern that lets judgement idle is spending down the constraint itself. A muscle you stop using and a queue you keep lengthening, at the same time.

What I do about it

The tools stay. I open Claude Code most days. What changed is how I budget the scarce thing. The scarce thing is my attention, and a few habits have settled in.

I do the thinking before I open the terminal. A decent brief, what to change, what to leave alone, what done looks like, takes genuine thought, and it’s the same thought the work would have needed anyway. The prompt box just relocated the blank page.

I keep the diffs small. I ask for changes in pieces I can hold in my head in one sitting. A 900-line diff gets skimmed, and skimmed approval is how quiet errors ship.

I aim the model where checking is cheap: scaffolding, migrations, renames, test boilerplate, the TMDL grunt work. A wrong answer in those places announces itself. The leash gets shorter where a wrong answer stays quiet: DAX that feeds a report someone will make a decision from, anything touching auth, anything I couldn’t verify without doing the work myself anyway.

And I’ve mostly stopped running three sessions at once. Parallel agents get marketed as multiplied output. What multiplies is the reading. On a good morning I can properly review perhaps five diffs. That number is embarrassing next to what the sessions can produce, and it’s the only number that governs what actually ships.

There’s a companion problem at the other end of the loop, the dead time while the model is still thinking, and I’ve already written that one up. This piece is about the moment the model finishes and you haven’t started.

The models will keep getting faster. Mine finished in under a minute last Tuesday; next year’s will finish before I’ve alt-tabbed back. I’ll still be reading at 238 words a minute.

The bottleneck has quietly moved, and unfortunately it’s me.