Switching doesn't come free
Every time your brain jumps from one kind of thinking to another, from email to code, from code to a meeting, from that meeting back to email, it pays a real cost. You just can't see the bill.
A 20-minute meeting feels like a 20-minute interruption. It's actually more than that: it's the meeting itself, plus whatever it costs to reload the mental state you were in before the meeting started, plus the cost of powering back down out of meeting mode afterward. Those reloading costs are frequently bigger than the meeting itself.
Researchers call this task-switching cost, and it's one of the more thoroughly replicated findings in cognitive psychology.
What the original study found
In 2001, researchers Joshua Rubinstein, David Meyer, and Jeffrey Evans ran four experiments asking people to do pairs of mental tasks (simple arithmetic, geometric judgments) under two conditions: doing the same task over and over, or alternating between two tasks.
Responses were reliably slower on switch trials than on repeat trials. The size of the cost changed with the tasks, how familiar their rules were, and how much preparation people had. The study established a mechanism, not a universal percentage that can be pasted onto every workday.
The researchers broke the cost into two pieces. First, you have to actively load the new task's goal into working memory. Second, you have to suppress the old task's rules so they don't bleed into the new one. Both take real mental effort, and together they're the tax you pay every time you switch.
What 23 minutes and 15 seconds actually measured
That lab result is a per-switch cost. Out in the real world, it compounds.
Gloria Mark's research group at UC Irvine ran a field study that became famous outside academia (Mark, Gudith & Klocke, 2008). The researchers observed office workers and timed the interval between an interruption and a return to the original task.
The average interval was 23 minutes and 15 seconds.
That number does not mean each 30-second Slack glance causes 23 minutes of mental fog. Workers often moved through other useful tasks before returning. The result captures the branching path of interrupted work: one message leads to a reply, the reply exposes another request, and the original document slips out of view.
That interpretation is less dramatic than the meme and more useful. The danger is not a magic recovery timer. It is losing the return path.
The part of the cost that lingers
University of Washington Bothell researcher Sophie Leroy found something extra in 2009, on top of the per-switch tax: she called it attention residue.
When you leave Task A to start Task B before A is actually finished, part of your attention doesn't come with you. That's not a figure of speech. Leroy measured worse performance on Task B specifically because of it.
Her experiments found that unfinished work could impair performance on the next task, especially when people had not disengaged from the first goal. The paper did not test a sixty-second closure ritual. Writing down the next step is a practical response to the mechanism, and one you can test for yourself.
That's why a meeting dropped into the middle of a coding session hurts more than the same meeting at the start or end of the day. Residue from the coding leaks into the meeting, and residue from the meeting leaks right back into the coding when you try to return to it.
Reduce the number of costly returns
You cannot remove every interruption, and trying to build a perfectly sealed day creates a brittle system. The useful question is simpler: which switches can you remove, and which returns can you make easier?
What works instead:
Containers. Keep everything tied to one project, its goals, calendar, notes, focus sessions, in a single place. Switching inside a container costs less than switching between containers, because the rules and goals stay continuous. It's the same logic behind dedicated project folders, single-purpose workspaces, and the old "one project, one room" habit.
Batching. Check email twice a day instead of every few minutes. Stack all your recurring one-on-ones into a single afternoon. Group shallow tasks (expense reports, status updates) into one block. Switching within a batch is cheap because the tasks already share the same rules.
Protected blocks. Pick a length that matches the work and your environment. Thirty quiet minutes can be valuable. So can ninety. Shut the inputs you do not need and judge the block by useful output, not by an arbitrary threshold.
Closure rituals. Before jumping from Task A to Task B, write one line: where you left off, and what comes next. Treat it as an experiment inspired by the attention-residue problem, not as a proven sixty-second cure.
What this looks like across a real week
- Mornings. A protected block for the single hardest task. No unnecessary inputs or tab-hopping.
- Midday. Shallow work batched into two 30-minute windows: email, Slack, admin.
- Afternoons. Meetings and collaborative work clustered together, since switching costs less when everything's already in "meeting mode."
- End of day. A five-minute closure ritual, and tomorrow's first task written down somewhere you'll actually see it.
It sounds rigid because it is rigid. That rigidity is the point. It's what's actually cutting the switching cost, instead of just hoping it goes away.
Leave a restart packet
Some switching is unavoidable. A restart packet reduces the cost of returning by storing the mental state you would otherwise rebuild.
Before leaving a task, write three lines:
- Current state: what is true right now?
- Next physical action: what should your hands do first on return?
- Open question: what uncertainty still blocks progress?
For a report, that might read: "The analysis is complete through August. Add the September export to the comparison table. Check whether refunds belong in gross or net revenue."
The packet should take under sixty seconds. If it becomes a polished summary, it creates a second task. Fragments are fine as long as tomorrow's version of you can restart without rereading the whole project.
Pair the note with a visible artifact. Leave the relevant file open, place the physical part beside the tool, or link the exact document in the next task. Context stored only in prose still requires a search.
Measure restart time for one week. Start the timer when you return and stop when useful work resumes. Compare tasks with and without packets. This gives you a personal switching cost and identifies which projects need stronger handoffs.
Use packets at intentional boundaries too. A clean stopping point lets you end focused work without rehearsing it all evening in case you forget. Attention can release the task because the return path exists outside your head.
Give each project one room
Spaces are the structural fix for switching cost. Every project gets its own container: its own tasks, calendar slots, notes, and focus sessions, all in one place. "One project, one room" is practically the user guide's slogan for it, and it's the Rubinstein-Meyer-Evans finding turned into an actual product.
Focus mode is the protected block, built in. One task, no other tabs, no inputs. The Daily Clock view batches similar work automatically, all your calendar-bound tasks in one strip and all your focus tasks in another, so the natural groupings are visible and easy to plan around.
Protect the return path
The research gives you no universal tax rate and no twenty-three-minute stopwatch. It gives you something better: a reason to notice what happens after an interruption.
For one week, measure only the returns that matter. When you stop a demanding task, leave a three-line packet. When you come back, time how long it takes before useful work resumes. Keep the packets that shorten that interval and ignore the rituals that merely look productive.
An interruption does not have to ruin the afternoon. It just needs a marked path home.