# 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.

- URL: https://shotmatic.app/blog/context-switching-too-many-projects
- Category: Multi-Project
- Published: 2026-10-05
- Author: Tu Nguyen

## Key takeaways

- 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.

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](https://shotmatic.app/blog/busy-all-day-nothing-shipped) — about the switch that looks free and isn't.

## 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](https://shotmatic.app/blog/run-10-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](https://shotmatic.app/blog/stop-re-explaining-your-project-to-ai) 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.

## Where ShotMatic fits

ShotMatic shows every project on one screen as one line — phase, next step, stuck or not — with ✦ to resume the
exact Claude session for that task. Coming back to a project is reading one line and clicking once.

## FAQ

**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.