When AI moves faster than your head

There is a kind of day that is becoming familiar for many developers working at the AI frontier: you start early, launch work across several code agents, review errors, relaunch, validate behavior… and at the end of the day the feeling is double.

On one side, obscene productivity: you do in a morning what used to take a week. You dare to start huge refactors and projects that would have felt absurd a year ago.

On the other, strange exhaustion: the head remains accelerated, it is hard to disconnect, sleep becomes light and interrupted. You wake up at 3AM thinking about a log, a job that got stuck or whether the prompt was specific enough.

The essential thing is that this is not just “more work”. We have changed role without fully noticing.

Before, we wrote the code. Now we specify, launch and orchestrate a small army of tireless agents. That change has effects we are still learning to manage.

The developer-orchestrator syndrome

When you launch work to an agent, you do not open only a process in the machine. You open a loop in your head:

• Did I specify it well enough?
• Will it get stuck on a silly error?
• How many iterations will it need?
• Should I be doing something else while it runs?

Even when nothing is happening on screen, inside you are still polling: now? now? now?

If you work with several agents in parallel, the number of open loops explodes. The mind does something very human: it does not fully release any of them. It keeps watching all of them at once. That is why you see the same symptoms: being always on guard, difficulty relaxing after work, light sleep and waking up already debugging.

This resembles the Zeigarnik effect: we keep processing incomplete tasks more than finished ones. AI, badly managed, turns the workday into a growing collection of incomplete tasks.

The trap of tireless AI

A human gets tired and goes home. An agent does not.

There is always one more thing:

• “While I am here, regenerate this with better logging.”
• “Let it start that refactor I do not want to do.”
• “Let it write the documentation while I have dinner.”

Each micro-improvement opens another loop. And because “the AI does it”, it becomes harder to say no. The workday ends in the calendar, but not in your head.

The paradox is real: the more productive you feel with AI, the more anxiety you can accumulate. Not because you do less, but because you open and maintain more parallel processes than your brain can carry without saturation.

From nervous thread to calm scheduler

The key is identity: stop behaving like one more thread inside the system and start acting as scheduler.

Some practical levers:

1. Set a launch boundary. After a certain hour, no new jobs unless there is a serious incident. Review, close and capture ideas, but do not open new loops.

2. Use fixed review blocks. Instead of checking compulsively whether the agent finished, define windows: 8:00-8:30, 11:00-11:30, 12:30-13:00. Outside that block, do not poll.

3. Assume iteration as part of the design. Iteration 1 is a draft. Iteration 2 fixes obvious errors and aligns structure. Iteration 3+ is fine tuning. If you know that 2-3 iterations are normal, you stop fighting reality.

4. Limit work in progress. Decide how many “hot” jobs you can have active: 3, 4, not 12. If you reach the limit, close something before launching more.

5. Create a daily shutdown ritual. Last 10-15 minutes: list open jobs, write next step, capture ideas for later and tell your brain that the system is watching.

These measures do not reduce AI power. They reduce the mental cost of exploiting that power.

Side-thinking: cognitive load engineering

What if this is not only a personal problem, but a new engineering layer?

Just as we design systems so they do not fall with 10x traffic, we need to design work systems so our brains do not fall with 10x power.

That opens three opportunities:

• a high-value skill: designing human-AI workflows that sustain productivity without burning people;
• tooling that visualizes open loops, active jobs, phases, review windows and WIP limits;
• a professional narrative where the value is no longer “I type everything myself”, but “I design systems where AI and people work well together”.

This also connects with the idea behind what PRs know that code does not tell: as agents increase throughput, the human role moves toward context, rules, review and system design.

The lesson

AI is not burning us only because it is powerful. It is burning us because it changed our role faster than we changed our rules.

We still behave as if we were the main thread, when in practice we have become the scheduler.

The practical question is simple and demanding:

Which two limits will you add tomorrow – time boundary, active jobs, review blocks – so your head returns to the rhythm of your life, not only the rhythm of your agents?