Almost every article about the cost of context switching quotes the same number: 23 minutes and 15 seconds to get back on task after an interruption. It's precise to the second, it comes from a respected UC Irvine researcher, and most pages quoting it get the meaning wrong.

I went back to where the five most-repeated numbers started — the papers and pages, not posts quoting posts. Two hold up, with caveats. The others are a real measurement with the wrong label, a remark promoted to a finding, and a table I couldn't trace to any data.

One note on terms, because "context switch" means something else in operating systems: there, it's the kernel saving one process's state so another can run. This article is about people — moving your attention from one task to another before the first is done. Psychologists study the lab version under the name task switching.

Short answer: research measures three different costs. In the lab, a switch slows your next response by a fraction of a second — around 200 milliseconds in a typical example — and preparing in advance shrinks that cost but doesn't remove it. A task you leave unfinished leaves attention residue that lowers your performance on the next one. And in real offices, interrupted work that's picked up the same day waits about 25 minutes first — that wait, not time spent refocusing, is where the famous "23 minutes" comes from.

What task switching costs in the lab

Each switch makes your first response on the new task slower and more error-prone — by about 200 milliseconds in Monsell's typical example — and some of that cost survives even when you know the switch is coming. Blocks that mix two tasks can run up to about a second slower per response than blocks of one task.

The classic demonstration is Rogers and Monsell (1995): people alternated on a fixed schedule between judging digits (odd or even) and letters (vowel or consonant). Up to 0.6 seconds of preparation cut the cost. Past that it stopped helping, and with 1.2 seconds to get ready "a large asymptotic reaction time (RT) cost remained."

Rubinstein, Meyer and Evans (2001) used harder tasks — sorting shapes and doing arithmetic under changing rules — in four experiments with 12 to 36 undergraduates each. Alternating cost 614 to 1,096 milliseconds per response over repeating one task: more for complex rules, less when a cue showed what came next.

Monsell's 2003 review adds a mixing cost: when a switch might come, people are slower even on trials where the task repeats, so switching taxes the whole block. Residual costs have shown up with five seconds or more to prepare. These are simple tasks under ideal conditions, though — nothing like a code review interrupted by a Slack thread. The next two lines of research get closer.

Attention residue: the part of your mind that stays behind

Attention residue is leftover thinking about task A after you've moved on to task B. Sophie Leroy showed it lowers performance on B, most of all when A was left unfinished.

In Leroy (2009), undergraduates spent five minutes on a word puzzle, then evaluated job candidates from their résumés. Those handed a puzzle that couldn't be finished recalled less from the résumés, and in a second experiment a reaction-time test showed the puzzle's words still active after the switch. Finishing wasn't always enough, either: people who finished at a relaxed pace carried more residue than people who finished under time pressure.

The study measured residue right after the switch, so it gives no duration in minutes. Pages that blame residue for refocusing taking more than 20 minutes are welding two unrelated findings together. And these were students on short lab tasks.

Leroy and Glomb (2018) looked at the task doing the interrupting. People who expected to return to the interrupted work under time pressure struggled to focus on the interruption. The fix that worked across four studies: before switching, note where you were and what you planned to do next. They call it a ready-to-resume plan, and it cut residue and protected performance on the interrupting task.

What interruptions cost at work

In the field, most interrupted work gets picked back up the same day, but after a long detour. In the lab, interrupted people speed up to compensate and pay for it in stress.

Mark, González and Harris (2005) shadowed 24 managers, analysts and developers for about three days each — more than 700 hours of observation — and tracked "working spheres", their term for a project-sized unit of work; 57% of them were interrupted. Interrupted work that came back the same day waited 25 minutes 26 seconds on average (standard deviation 54 minutes 48 seconds), with 2.26 other spheres in between.

In the lab, Mark, Gudith and Klocke (2008) had 48 people answer work emails while a "supervisor" interrupted them about every two minutes. Interrupted rounds finished faster than the quiet one, with no difference in errors or politeness — people wrote shorter emails. The price was in the questionnaires: more stress, frustration, workload, effort and time pressure "after only 20 minutes of interrupted performance."

Timing changes the cost. Iqbal and Bailey (2008) held notifications until a natural breakpoint in the task. With 16 people programming or editing diagrams, that cut frustration and reaction time compared with immediate delivery, for an average delay under 90 seconds; it didn't shorten resumption. I build Timex, a Mac time tracker, and this study is why its Energy nudges wait for an app switch or a minute's pause.

The famous context switching stats, audited

The five numbers that turn up most often, traced back to where they started:

Claim as usually quoted Where it really comes from What was measured Verdict
"It takes 23 minutes 15 seconds to refocus after an interruption" Gloria Mark in a 2006 Gallup interview about 36 people she shadowed; her 2005 paper on 24 people reports 25 min 26 s How long observed office workers took to return to an interrupted project the same day, after about two other projects Real number, wrong meaning. It's a detour between projects, not time spent regaining focus. The paper's 25-minute mean has a standard deviation of 54 minutes, more than twice the mean; the interview gives none.
"Switching tasks costs up to 40% of your productive time" An APA page from 2006 Nothing at that size. The page reports a remark by David Meyer ("as much as 40 percent") and says single switches can cost "just a few tenths of a second" Stretched. An upper-bound remark, not a result.
"Workers toggle between apps 1,200 times a day, losing 4 hours a week" Murty, Dadlani and Das, HBR 2022 137 workers, mostly in mid- or back-office jobs (finance, HR, supply chain…), at three Fortune 500 companies, for up to five weeks; each toggle took "little over two seconds" to reorient Holds, for that group. Two of the three authors work at Soroco, which builds the measuring software. The four hours is roughly two seconds times 1,200 toggles a day, added up over a week — not lost focus.
"Each extra project or task eats 20% of your time" A table in Gerald Weinberg's 1992 book Quality Software Management, p. 284, as cited by Chris Gagné Switching between concurrent projects; I found no study or dataset behind the table Unverified estimate. About projects, not app switches.
"A five-second interruption triples your errors" Altmann, Trafton and Hambrick (2014) 300 undergraduates following a fixed sequence of steps: 4.4-second interruptions tripled sequence errors, 2.8-second ones doubled them; other errors didn't change Holds, narrowly. It's about losing your place in a step-by-step procedure.

Two rows can't both mean what they're usually taken to mean. If every app toggle cost 23 minutes 15 seconds, HBR's 1,200 daily toggles would take 465 hours a day. Read the sources and the contradiction disappears: one is a two-second reorientation after flipping windows, the other a 25-minute detour before people pick an interrupted project back up.

How to measure your own context switching

Count your app switches per hour from a record of your day. It's the one part of the cost you can observe directly; residue and resumption you can only infer.

No install. The free day audit tool has you paint your last eight hours onto a 24-hour timeline and reports deep blocks and a task-switch count. It runs on memory, so treat the count as an estimate.

From a recorded day. Timex samples the frontmost app once a second into one local SQLite file, one row per tracked segment: the app's bundleId, window title, URL, start, end and duration. Open the file in the free SQLite viewer, which runs in your browser with no signup. Use a ZIP export from Settings or the file in ~/Library/Application Support/io.muvon.timex/, then paste one query at a time.

App switches per clock hour for one day (change the date):

WITH seq AS (
  SELECT startAt,
         bundleId <> LAG(bundleId) OVER w
           AND (julianday(startAt) - julianday(LAG(endAt) OVER w)) * 86400 < 120
           AS switched
  FROM activity
  WHERE date(startAt, 'localtime') = '2026-10-08'
  WINDOW w AS (ORDER BY startAt)
)
SELECT strftime('%H', startAt, 'localtime') AS hour,
       COUNT(*) FILTER (WHERE switched) AS app_switches
FROM seq
GROUP BY hour
ORDER BY hour;

Switches per tracked hour, one row per day from a start date:

WITH seq AS (
  SELECT date(startAt, 'localtime') AS day,
         duration,
         bundleId <> LAG(bundleId) OVER w
           AND (julianday(startAt) - julianday(LAG(endAt) OVER w)) * 86400 < 120
           AS switched
  FROM activity
  WHERE date(startAt, 'localtime') >= '2026-10-01'
  WINDOW w AS (PARTITION BY date(startAt, 'localtime') ORDER BY startAt)
)
SELECT day,
       COUNT(*) FILTER (WHERE switched) AS app_switches,
       ROUND(SUM(duration) / 3600.0, 1) AS tracked_hours,
       ROUND(COUNT(*) FILTER (WHERE switched) * 3600.0 / SUM(duration), 1) AS switches_per_hour
FROM seq
GROUP BY day
ORDER BY day;

Three rules keep the count honest:

  • A switch is a row whose bundleId differs from the previous row's — not just any new row, since a window-title change inside one app may also start one.
  • The gap must be under 120 seconds. Timex closes a segment after 120 seconds without keyboard or mouse input (audio playing or a live mic in the front app keeps it open), so a longer gap means you stepped away, and returning to a different app after lunch isn't a switch.
  • Timex stores times in UTC, so every day and hour goes through SQLite's 'localtime' modifier to match your clock.

I tested both before publishing, on a 14-row database stored in UTC and read in a UTC+7 time zone: eight known switches, plus two same-app rows, a 15-minute away gap, a two-hour gap, a row from the previous local day and a row that is on the previous day in UTC but on the queried day locally. Both queries returned exactly eight switches, split 4, 2 and 2 across the 9, 10 and 11 o'clock local hours — in Python's sqlite3 and in sql.js, the WebAssembly build the viewer ships.

Then read the number for what it is. At HBR's two-odd seconds per reorientation, even 40 switches an hour cost about a minute and a half — the seconds aren't the expensive part. Look for the hours where switches spike inside your longest stretches of real work. Mine looked like a "solid morning of coding" that was really forty minutes, cut nine times; I wrote up what that did to my focus sessions. If you write code, the post on time tracking for developers shows how editor, terminal, AI tools and chat separate in the same data.

What reduces the cost of context switching

Fewer switches, switches at natural boundaries, and a note before you leave. Each has a specific study behind it.

  • Batch the small stuff. Every switch has a fixed cost, and mixing tasks slows even the moments you don't switch. Answer messages in a few sittings, not as they land. Mark's 2008 study found same-topic interruptions no cheaper than off-topic ones, so the gain is fewer switches, not grouping "related" ones.
  • Protect blocks, and expect to interrupt yourself. In Mark's 2005 study, analysts and developers interrupted themselves about as often as other people interrupted them. Notifications off covers half of it; the other half is catching the urge to check something.
  • Stop at a boundary when you can. Leroy found finishing reduces residue, and Iqbal and Bailey found interruptions at breakpoints frustrate people less. Finish the function, the paragraph or the reply, then switch.
  • When you can't finish, leave a ready-to-resume note. Leroy and Glomb's fix takes about a minute: where you were, what you'd do next. They measured the interrupting task, but the note should help the trip back too — Rubinstein's participants switched faster when a cue showed what came next, and the note is that cue.

Is context switching fatigue real?

Partly. The short-term strain has direct evidence: Mark's 2008 participants rated their stress, frustration and effort higher after 20 minutes of interrupted work. The long-term version — constant switching grinding you into burnout — isn't something these studies tested, and the authors say so: "We cannot say whether people would cope over time or if these measures would only increase." The HBR toggling article says heavy toggling raises cortisol, but cites nothing for it. Treat claims of lasting damage as unproven.

The honest limits

The lab work behind these numbers uses simple tasks, mostly with undergraduates; the field study behind the 25-minute figure watched 24 people. None of it gives you a personal cost per switch, and I'd distrust any tool that claims to.

The queries count app switches, not attention switches. Thinking about the bug while you answer email is invisible, and so is moving between tabs in one browser or files in one editor — that all stays inside one bundleId. Timex sees only your Mac, so the phone you picked up mid-task never shows up. And Timex records switches; it doesn't block them.

Count one week

Don't change anything the first week. On Friday, run the second query, find your worst hour with the first, and try one fix in that hour only. A count you can compare beats a stat you can quote.

Timex's trial covers 100 hours of tracking with no credit card, on macOS 15 or later with Apple Silicon. Download Timex, work a normal week, and count.

— DK