Skip to content
ONECLICKTOOLINDEPENDENT STUDIO

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.

By · Oct 5, 2026 · 2 min read

RedditXLinkedInFacebook
A developer glances anxiously between two monitors full of code from different projects.
On this page · 7 sections
  1. The short answer
  2. Agents create gaps, gaps invite switches
  3. Make switches cheap instead of rare
  4. Only switch to projects with a written next step
  5. Three active, the rest parked
  6. Keep reading
  7. Frequently asked questions

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:

  1. Where it is — the phase.
  2. What's next — one action.
  3. 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.

Sources

  1. Claude Code overview — Anthropic docs
  2. Common workflows — Claude Code docs

Found this useful? Share it on Reddit or pass it on.

RedditXLinkedInFacebook