If AI Is Faster, Why Are You So Tired?

SAMI
November 22, 2026 16 mins to read
Share

The work did not vanish when the agents arrived. It changed shape, and the new shape is harder on the brain than it looks.

The question I keep hearing

I spend a large part of my week helping developer teams adopt generative AI. I run the internal trainings, I field the “which tool should we standardize on” debates, and I use Claude Code and GitHub Copilot every day. Enthusiasm is part of my job description.

And yet the question I hear most often after a session has nothing to do with prompts or models. It sounds like this: “I ship more than I ever did. So why am I empty by four in the afternoon?”

Fran Soto asked the same thing in a recent issue of the Strategize Your Career newsletter, and the answer there is a good starting point: the effort moved from typing code to reviewing it, switching between agents and making decisions for them. I agree with that diagnosis. I also think it stops too early. Over the last eighteen months, researchers at METR, Berkeley, BCG and Google’s DORA team have published data that explains much of what developers feel, and a 1983 paper on factory automation explains the rest.

This article connects the two: what developers report, and what the evidence says about why. Then it gets practical, with what I now tell teams to change, from the individual developer up to the organization that sets the pace.

What the evidence says

The tiredness is not in your head. Six studies, published between early 2025 and spring 2026, point in the same direction from different angles.

StudyWho and howWhat it found
Bedard et al., BCG and UC Riverside, HBR, March 2026Survey of 1,488 full-time US workers in large companiesNamed “AI brain fry”: mental fatigue from using or overseeing AI tools beyond your cognitive capacity. 14% of AI users reported it, with more errors, more decision fatigue and a higher intent to quit. Software development ranked among the most affected roles.
Ranganathan and Ye, UC Berkeley, HBR, February 2026Eight months of fieldwork in a 200-person US tech companyPeople worked faster, took on tasks outside their role and spread work into evenings and breaks, often unasked. The authors call it workload creep and link it to fatigue and weaker decisions.
Stanford Social Media Lab and BetterUp, HBR, September 2025Survey of 1,150 US desk workers40% had received “workslop” (AI output that looks finished but is not) in the previous month. Each case took close to two hours to sort out.
DORA, State of AI-assisted Software Development, September 2025Nearly 5,000 technology professionals90% use AI at work and more than 80% feel more productive, yet 30% trust AI code little or not at all. AI amplifies a team’s existing strengths and weaknesses, and is still linked to more delivery instability.
METR randomized trial, July 202516 experienced open-source developers, 246 real tasks in their own repositoriesWith early-2025 tools, tasks took 19% longer. Developers had expected a 24% speedup and, after the slowdown, still believed AI had made them 20% faster.
Lee et al., Microsoft Research and Carnegie Mellon, CHI 2025319 knowledge workers, 936 real use casesCritical thinking shifts toward verifying output, integrating it and stewarding the task. The more people trust the AI, the less critical thinking they apply.

Two signals come out of this table. The first is a perception gap. METR’s developers felt faster while being measurably slower, which tells me our sense of speed is a poor instrument. The study used early-2025 tools and its authors are careful not to generalize, but the gap between feeling and measurement is the part I would bet survives newer models.

The second signal is intensity. The Berkeley and BCG studies describe the same mechanism from two sides: AI makes it cheap to start things, so people start more of them, and the cost shows up later as attention spread too thin. Most of these numbers are self-reported, so treat them as strong signals rather than settled science. What convinces me is that a survey, an ethnography and a controlled trial land in the same place.

Fatigue, burnout or brain fry?

The words matter, because they lead to different fixes. Fatigue is the normal cost of a hard week and a weekend repairs it. Burnout is what months of chronic stress produce: exhaustion plus cynicism about the work plus a feeling of being less effective. It is a reason to talk to someone, not to install a new productivity app. AI brain fry sits between the two. It is acute, tied to a specific pattern of work (too many AI threads, too much oversight) which means it points at something you can change. The BCG authors are explicit that it is a distinct phenomenon from burnout, and the label is new enough that I use it as a useful description, not a diagnosis.

Where the energy went

Picture an ordinary Tuesday in 2026. One Claude Code session is refactoring a payment module, a second is generating tests for a REST API, a third is drafting a database migration. You are in a meeting. Your phone shows that one of them is waiting for an answer. None of this feels like hard work, and all of it is draining you. Four costs hide in that picture.

Supervision has no natural pauses

Before agents, the job had built-in breathing room. You waited for the build, you waited for the test suite, you stared at a stack trace and went for coffee. Soto makes this point well: supervising never stops, because with several agents running there is always something finished and waiting. The agents keep working during your commute, so the temptation to check on them does too.

The Berkeley study saw the same thing at company scale: once starting a task cost one prompt, people slipped work into lunch, evenings and the minutes between meetings. The pauses did not disappear because someone took them away. We gave them up ourselves, one prompt at a time.

Switching leaves residue

Sophie Leroy, who studies interruptions at the University of Washington Bothell, coined the term attention residue: when you move from task A to task B, part of your mind stays with A, and your performance on B drops, especially when B is demanding. The residue is worst when A is unfinished and you know you will have to rush back to it.

That is an exact description of running parallel agents. Every session you leave is unfinished by design. Soto admits to asking each agent “where are we and what is left?” several times a day, and I recognize myself in that. The agent is not confused. I am, because I carry four half-loaded contexts in my head.

Gloria Mark’s lab at UC Irvine found something uncomfortable back in 2008: interrupted people complete tasks faster, but they report significantly more stress, frustration, time pressure and effort. Speed and strain rise together. That is a decent one-line summary of agentic development today.

Verifying code you did not write

Reviewing your own code is cheap because you built the mental model while typing it. Reviewing an agent’s diff means building that model from zero, in minutes, for code whose intent you have to reverse-engineer. If you did not specify the intent clearly up front, you do that thinking during review anyway, under time pressure.

The Microsoft and Carnegie Mellon study describes this shift precisely: AI reduces the effort of producing work and increases the effort of verifying, integrating and taking responsibility for it. It also found a trap. The more people trust the AI, the less critically they review. So a tired reviewer faces two bad options: spend energy they no longer have, or wave the diff through.

Deciding, all day, at high speed

When generating an option costs nothing, you get more options. Three approaches to the migration, two versions of the test plan, a suggestion to refactor a neighbouring module while the agent is at it. Each one is a small decision, and each decision lands on you. The BCG researchers measured this directly: workers with brain fry reported more decision fatigue and more mistakes, both minor and serious.

Add it up and the day gets denser without getting longer. You work the same hours, but more of them are spent at full cognitive load, with fewer of the low-intensity moments that used to let the brain recover.

A leaky abstraction, and a lesson from 1983

Every big jump in programming productivity came from an abstraction we could stop thinking about. I never read the assembly my compiler produces, and I do not need to, because the compiler is deterministic. Same input, same output, every time.

An AI agent also lifts us up a level of abstraction, but it leaks. Even with a good spec, solid skills files and a disciplined workflow, the agent can take the code somewhere you did not intend. So you keep descending to the line level to check. You get the stress of being a manager and the stress of being a reviewer in the same day.

None of this is new to people who study automation. In 1983, the cognitive psychologist Lisanne Bainbridge published a five-page paper called Ironies of Automation, about operators in power plants and chemical factories. Two of her ironies describe the AI-assisted developer with uncomfortable accuracy.

The first concerns monitoring. Bainbridge cited vigilance research showing that even a highly motivated person cannot keep effective attention on a source where very little happens for much more than half an hour. Her conclusion was blunt: watching for rare abnormalities is humanly impossible to do well, so it has to be handed to automatic alarms. Now think about reviewing the twentieth agent diff of the day, where nineteen were fine.

The second concerns skill. An operator who only monitors gets less practice, so when the automation fails, the person expected to take over is less able to do it. The developer who has not written concurrent code by hand in six months is the one asked to spot the subtle race condition in the agent’s output. The better the agent gets, the rarer its mistakes become, and the harder they are to catch.

This is why “just review more carefully” is not a strategy. A reader under Soto’s post, Andrii Tretiak, described what worked for him after a year of agentic work: he stopped reading every diff line by line, moved that work to separate automated checks, and now reads the findings, going into the code himself only where a mistake would be expensive. That is Bainbridge’s advice applied forty years later. You keep human attention for the places where it pays, and you build alarms for everything else.

In a bank, you cannot just skip the review

I work in banking IT, and this is where the fatigue question stops being a wellbeing topic and becomes an operational risk.

In a startup, an exhausted developer who rubber-stamps an agent’s pull request ships a bug. In a regulated institution, the same signature sits in an audit trail. Four-eyes review, segregation of duties and change management exist so that a named human is accountable for what reaches production. Agents multiply the number of changes that need that signature. They do not multiply the number of reviewers, or the hours in their day.

Regulators already assume that a tired human will over-trust a machine. Article 14 of the EU AI Act requires that people overseeing high-risk AI systems remain aware of automation bias, the tendency to rely too much on automated output. Legal scholars have noted that it is the only cognitive bias the Act names explicitly. A coding assistant is not a high-risk system under the Act, but the logic carries over to any team whose job is to sign off on machine output. If you work for a European group, as many engineering teams here in Tunis do, expect auditors to ask how your developers review AI-generated code, and whether that review is real.

The uncomfortable part is that the code where review matters most, such as payment flows, access control and regulatory reporting, gets its share of agent-generated changes too, and the people who review it are as tired at the end of the day as everyone else.

What I push for in this context:

  • Tier the codebase by risk and write the tiers down. Test scaffolding and internal tooling can go through lighter human review backed by automated checks. Payment logic, authorization code and anything that feeds a regulator gets a full human review, by someone with the time to do it.
  • Make the machines do the vigilance. Static analysis, security scanning, policy checks and test coverage gates belong in the pipeline, before a human sees the diff. Automating security analysis is a large part of my own work for exactly this reason: every finding a tool raises is one a tired reviewer does not have to spot.
  • Cap the review load for critical code. A limit on how many agent-generated changes one person approves per day for the top risk tier is a control, and it can be written into the process like any other.
  • Keep the intent upstream. A short spec or ticket that states what the change should and should not do turns review from archaeology into comparison.

What to change, from your desk to the org chart

Soto proposes three habits: limit open tasks, take scheduled breaks, and set a hard stop to the day. I use all three and recommend them. They treat the symptoms an individual can reach. The research says the causes also sit in how teams review and in what organizations expect, so the playbook below works at three levels.

For you, starting this week

  1. Put a WIP limit on your agents. Two or three active sessions is plenty for most people. Finish or park one before you open another. The BCG data supports this: a small set of AI tools went with productivity gains, and adding more tools eroded them.
  2. Leave a ready-to-resume note every time you switch. Leroy and Glomb showed that writing down where you stopped and what comes next frees the mind to move on. With agents you can delegate the note: ask each session to keep a short progress file that it updates before it pauses, so “where are we?” becomes a file you read in thirty seconds.
  3. Review in windows, not on notification. Turn off agent alerts on your phone. Pick two or three moments a day to review finished work in a batch, with your full attention.
  4. Spend more time before the prompt. Five minutes writing intent, constraints and acceptance criteria saves far more than five minutes of reverse-engineering a diff later.
  5. Keep one block of hands-on work. Write some code, design something or debug without an agent every day or two. It keeps the skill you will need on the day the agent is wrong, which is Bainbridge’s second irony turned into a habit.
  6. Keep Soto’s two guards. A timer for real breaks, and something scheduled after work that physically takes you away from the laptop.

For your team

  1. Build the AI workflow together. In the BCG study, teams that wove AI into shared workflows reported less strain than people who adopted tools on their own, and fatigue dropped when managers took time to answer AI questions.
  2. Work in small batches. DORA lists it among the seven capabilities that make AI pay off. Agents happily produce a 2,000-line pull request, but no one can review one well at five in the afternoon.
  3. Put automated checks in front of human eyes. Tests, linters, security scanners and AI review bots run first. The human reads what they flagged and the parts of the code where an error is expensive.
  4. Count review as work. If planning only counts code produced, review time becomes invisible overtime. Give it explicit capacity and rotate the heaviest review duty.

For your organization

  1. Stop measuring AI adoption by volume. Some companies reward token consumption or the amount of AI output, and the BCG researchers found that people who felt their employer expected more output because of AI reported more fatigue.
  2. Say out loud what the time savings are for. If saved time silently turns into more scope, you get the workload creep the Berkeley team documented. Decide which share goes to quality, learning and recovery.
  3. Sequence the work. The Berkeley authors recommend moving projects forward in deliberate phases, with short structured pauses before major decisions, instead of at whatever pace the tools allow.
  4. Treat cognitive load as a job risk. The BCG authors recommend tracking it in people analytics, the way you would track overtime or attrition. In regulated environments, add it to the operational risk discussion.

So, why are you so tired?

Because the agents took the part of the job that let you rest and left you the part that never does. Typing code was slow, but it was low-intensity work with built-in pauses. Judging code, switching contexts and making decisions is the most expensive work a brain does, and the tools now let you do it all day long.

The AI is faster. Your attention is not, and it does not scale with the number of terminal tabs you open. Generation now runs ahead of comprehension, and the gap between the two is where the fatigue comes from.

I still want every developer I train to use these tools. I also want them to measure success by the amount of good work they can sustain for a year, not by how much they can generate in a week. That means fewer parallel threads, reviews backed by machines, intent written before the prompt, and organizations that decide where the saved time goes. If the tiredness lasts for months and comes with cynicism about the work, it is no longer brain fry, and it deserves a conversation with someone you trust.

Sources

Leave a comment

Your email address will not be published. Required fields are marked *