Stop Context Switching While Your AI Agent Runs

The Context Switching Tax on AI-Assisted Development

Every time you glance at your agent's terminal to check if it is done, you pay a tax. Not in money, but in attention. Research from the University of California, Irvine found that it takes an average of 23 minutes and 15 seconds to fully regain focus after an interruption. Even a quick tab switch, just a second or two of looking, resets part of that clock.

AI coding agents have introduced a new and constant source of these micro-interruptions. You fire off a prompt, the agent starts working, and now you have a choice: stare at the terminal or try to do something else. If you do something else, a low-grade monitoring loop starts running in the back of your mind. Is it done yet? Did it hit an error? Should I check?

This is the context switching tax on AI-assisted development. It is not the agent's work that slows you down. It is the cognitive overhead of tracking the agent's state while trying to focus on your own work. And unlike a single interruption you can recover from, this one repeats every few minutes across the entire workday.

Why Developers Keep Checking

The checking behavior is not irrational. It comes from a real problem: agent idle time. When an AI agent finishes a task and waits for your next instruction, every second of that wait is wasted throughput. You know this, so you feel pressure to respond quickly. That pressure turns into compulsive tab-switching.

There is also an uncertainty problem. You do not know how long the agent will take. Some prompts finish in 10 seconds. Others run for 3 minutes. Without a predictable cadence, you cannot plan when to check. So you check constantly, or you force yourself not to check and then feel anxious about it.

The result is a worst-of-both-worlds situation. You are neither fully focused on your primary task nor fully engaged with the agent. You are hovering between the two, doing both poorly. A study by Michigan State University found that interruptions as short as 2.8 seconds were enough to double the rate of errors on a primary task. That "quick glance" at the terminal is not free.

The Async Mindset for AI Pair Programming

The fix starts with reframing how you think about agent work. Your AI agent is not a pair programmer sitting next to you. It is an async collaborator. You should interact with it the same way you interact with a colleague in a different timezone: send the request, move on, respond when they get back to you.

This mental shift matters because it changes your behavior. When you treat the agent as synchronous, you wait for it. When you treat it as async, you fill the gap with other meaningful work. Code review, documentation, a different feature branch, or even running a second agent on a separate task.

But the async mindset only works if you have a reliable notification mechanism. Async communication with a colleague works because Slack pings you when they reply. Without that ping, async becomes "check your messages every 30 seconds," which is worse than synchronous. The same applies to agents.

Building a Notification-Based Workflow

The goal is simple: replace polling with push notifications. Instead of you checking the agent, the agent (or something watching the agent) tells you when it needs attention.

Pulser is a free macOS menubar app built for this exact workflow. It monitors your terminal processes and sends a native Mac notification the moment an AI agent stops and waits for input. You hear the ping, switch over, give your next instruction, and switch back. The round-trip takes seconds instead of minutes.

This is the same pattern that makes modern async work possible everywhere else. CI pipelines notify you when builds finish. PR bots notify you when reviews are requested. Your agent should notify you when it needs your input. Pulser closes that gap.

With notifications in place, the context switching tax drops dramatically. You stop the mental polling loop entirely. You are not checking, not wondering, not hovering. You are working on something else with full focus until you hear otherwise.

Practical Setup for Async Agent Work

Here is how to structure your day around async agent work. First, install Pulser and let it watch your terminal sessions. It works with Claude Code, Cursor, Windsurf, Codex, and any terminal-based agent.

Second, always have a secondary task queued. Before you send a prompt to your agent, know what you will work on while it runs. This can be as simple as reviewing a diff, writing a commit message, or reading through a spec. The point is to avoid the "prompt sent, now what?" moment that leads to idle staring.

Third, batch your agent interactions. Instead of sending small, incremental prompts that finish in seconds, give your agent larger, well-defined tasks. A bigger task means a longer uninterrupted block for you. Instead of "add a validation check to this field," try "add input validation to all form fields in this component, with error messages and unit tests."

Fourth, if you are running multiple agents, keep each one in a separate terminal session. Pulser will monitor all of them independently and tell you which one needs attention. This lets you run two or three workstreams in parallel without the cognitive overhead of tracking each one yourself.

Measuring the Difference

The impact shows up in two places: your agent utilization and your own focus quality.

On the agent side, track your average response time. How long does your agent sit idle before you notice? Without notifications, this is typically 1 to 5 minutes. With a notification-based workflow, it drops to under 15 seconds. Over 20 agent cycles in a day, that difference adds up to 30 to 90 minutes of reclaimed productive time.

On the focus side, pay attention to how many times you context switch per hour. Before adopting this workflow, most developers switch to check their agent 15 to 30 times per hour. After, the only switches are in response to actual notifications, which might be 5 to 8 times per hour. Each avoided switch is a chance for your brain to stay in flow instead of resetting.

The compounding effect is significant. Deeper focus means higher-quality work on your primary tasks. Faster agent response means higher agent throughput. And the two reinforce each other: when you trust the notification to come, you commit more fully to your current task, which makes you more productive even apart from the time savings.

Context switching is not a willpower problem. It is an infrastructure problem. Solve it with better tooling, not with more discipline.