Context Switching Between Too Many AI Projects Kills Your Day
Waiting on one agent, you peek at another project, then a third. Why context switching costs more with AI agents, and a simple rule to keep switches cheap.

On this page · 7 sections
The agent is running a long task on project A. Two minutes to wait. You open project B "just to check". B needs a small fix, so you start it. Then A finishes, but you're mid-thought in B. Then a notification from C.
By lunch you've touched five projects and moved none. This is part 2 of Busy, Not Shipping — after busy all day, nothing shipped — about the switch that looks free and isn't.
The short answer#
- Agents create waiting time, and waiting time invites switching to another project — which costs you a re-read every time you come back.
- The cost of a switch is the time to reload a project into your head; you can't avoid switches, but you can make them cheap.
- A switch is cheap when each project's phase, next step and open session are written down where you can see them at a glance.
- Cap active projects per day at three; everything else stays visible but parked.
Agents create gaps, gaps invite switches#
Working alone, you rarely wait on yourself. Working with agents, you wait all the time — for a build, a test run, a long refactor. Those gaps feel like wasted time, so you fill them with another project.
The switch itself takes a second. Coming back is what costs: re-reading where you were, what the agent changed, what you were about to decide. Do that twenty times a day and the gaps you were "saving" cost more than they saved.
Make switches cheap instead of rare#
You won't stop switching — with agents, some switching is the point. The goal is to make each one cheap.
A switch is cheap when you can reload a project in seconds. That needs three things written down, per project:
- Where it is — the phase.
- What's next — one action.
- Where the conversation is — the session to resume.
If you can see those three things for every project on one screen, coming back is a glance, not an archaeology dig. That's the core of running many projects in parallel.
Only switch to projects with a written next step#
A simple rule that prevents most bad switches:
While an agent runs, only switch to a project whose next step is already written down.
If B's next step is "write 3 screenshot captions", you can do it in the gap and come back. If B's next step is "figure out what's going on", don't open it now — it will swallow the afternoon.
The same rule makes session handoffs easy: the written next step is exactly what you'd stop re-explaining to the agent.
Three active, the rest parked#
Decide each morning which three projects are active today. The others are not forgotten — they're parked, visible, with their next step written. When an active project is waiting on an agent, switch to another active project, not a parked one.
At the end of the day, write the next step for each active project before closing. Tomorrow's switches start cheap.
Keep reading#
Frequently asked questions
How many side projects can I work on at once with AI agents?
Many can be open, but only a few should be active on the same day. Three active projects with cheap switches beats ten with expensive ones.
What makes context switching expensive?
Reloading the project into your head: where it was, what the agent was doing, what you decided. If that lives only in memory, every switch means re-reading chats and diffs.
What should I do while an agent is running?
Review the previous result, write the next step down, or switch to a project whose next step is already written. Avoid opening a project you'd have to rediscover.


