Most engineering jobs are interrupt-driven by design. There is a pager, a review queue, a team channel, a product manager with a quick question, and a calendar that fills itself. Nobody chose fragmentation, but it is the default, and the work that matters most (designing a system, debugging something subtle, writing a careful document) is exactly the work that suffers from it.

The topic attracts a lot of folklore: "it takes 23 minutes to refocus", "multitasking lowers your IQ", "never check email before noon". Some of it is roughly right, some is misquoted, and some has no source at all. The actual research is more useful than the folklore, because it explains why switching hurts and points to specific, cheap countermeasures.

This post collects the core findings with their sources, clears up the most quoted number, and turns it into a playbook for engineers. It is the last week of the year, so it ends with a planning angle: use your calendar from this year to design next year's.

1. Definitions

Term Meaning
Context switch Moving attention from one task to another, voluntarily or not
Interruption An external (message, person, alert) or internal (a thought, an urge to check something) event that suspends the current task
Attention residue Sophie Leroy's term for thoughts about a previous task that persist while you work on the next one
Working sphere Gloria Mark's unit of analysis: a set of related activities toward one goal (a project, a bug, a report), as opposed to a single action
Deep work Cal Newport: "Professional activities performed in a state of distraction-free concentration that push your cognitive capabilities to their limit"
Shallow work Newport's counterpart: logistical, not cognitively demanding tasks, often done while distracted and easy to replicate
Maker's / manager's schedule Paul Graham: days organized in half-day blocks vs. one-hour slots

2. Attention residue (Leroy, 2009)

Sophie Leroy, then at the University of Minnesota, published "Why is it so hard to do my work? The challenge of attention residue when switching between work tasks" in Organizational Behavior and Human Decision Processes (vol. 109, issue 2, 2009, pp. 168-181).

The core claim, from the abstract: "People need to stop thinking about one task in order to fully transition their attention and perform well on another." Her experiments found:

  • Unfinished tasks leave residue. When people switched away from a task they had not completed, their attention stayed partly on it, and their performance on the next task suffered.
  • Finishing is not enough. Completing the first task before switching did not by itself remove the residue.
  • Finishing under time pressure helped. When the first task was completed under time pressure, people disengaged more fully and did better on the next task. Leroy's explanation is that finishing under a deadline gives a stronger sense of closure.

What this means in practice: the cost of a switch is not only the seconds spent changing windows. It is the reduced quality of attention you bring to whatever comes next, while part of your mind is still on the previous thing.

The countermeasure: a ready-to-resume plan (Leroy and Glomb, 2018)

A follow-up paper by Sophie Leroy and Theresa Glomb ("Tasks Interrupted", Organization Science, vol. 29, issue 3, 2018) tested a simple intervention across four studies. When people expected to return to an interrupted task under time pressure, residue was high and their performance on the interrupting task was low. A brief ready-to-resume plan before switching reduced residue and restored performance on the interrupting task.

According to the University of Washington's summary, the plan notes "where to resume, what challenges are left, and/or what actions (you) must postpone but resume later", and Leroy said "even a minute's work will do".

For engineers, that is a one-line note in the ticket or a comment at the top of the file: "Next: check why the retry fires twice; suspect the timeout in client.py:142." It costs a minute, and it lets your brain stop holding the open loop.

3. Fragmented work in the field (Mark, Gonzalez and Harris, 2005)

Gloria Mark (UC Irvine) and colleagues observed information workers at an IT company: 24 people (7 managers, 9 analysts, 8 developers), each formally timed for about three days, more than 700 hours of observation in total. The paper, "No Task Left Behind? Examining the Nature of Fragmented Work", was presented at CHI 2005.

Key findings:

Finding Number
Share of working spheres that were interrupted 57%
Average continuous time in a working sphere before switching About 11 minutes
Share of interrupted work resumed the same day 77.2%
Average time until interrupted work was resumed (same day) 25 min 26 s (standard deviation 54 min 48 s)
Other working spheres engaged in before resuming 2.26 on average

Two details matter for interpretation:

  • The 25 minutes is the elapsed time between the interruption and returning to the task, during which people typically worked on more than two other things. It is not "the time it takes to refocus" in the sense of a mental warm-up.
  • The standard deviation is about twice the mean. Some interruptions were resumed in seconds, others hours later. The average describes a very skewed distribution.

The paper's own summary: "Though most interrupted work is resumed on the same day, more than two intervening activities occur before it is." The informants described this as very detrimental, partly because the physical and digital cues (open windows, the cursor where you left it) are often gone by the time they come back.

About "23 minutes and 15 seconds"

The figure "it takes 23 minutes and 15 seconds to refocus after an interruption" is widely attributed to Gloria Mark and often cited to her 2008 paper. It is not in that paper. The number does trace back to Mark: in a June 2006 Gallup Management Journal interview she said that "most interrupted work was resumed on the same day -- 81.9 percent -- and it was resumed, on average, in 23 minutes and 15 seconds."

So the popular version gets two things wrong:

  • It is not a refocusing time. Like the 25 min 26 s in the peer-reviewed 2005 paper, it measures how long until people got back to the interrupted task, usually after doing other things in between.
  • It is not from the 2008 study. The peer-reviewed field figures are the 2005 ones (77.2% resumed the same day, 25 min 26 s on average). Mark, in a 2023 UC Irvine podcast, used the same order of magnitude: "it takes about 25 and a half minutes to pick up that original interrupted project".

If you want to cite a number, cite the 2005 paper and say what it measures: on average, interrupted work was resumed about 25 minutes later, after more than two other activities.

4. Interrupted work is faster and more stressful (Mark, Gudith and Klocke, 2008)

The 2008 lab study, "The Cost of Interrupted Work: More Speed and Stress" (CHI 2008, Florence), tested 48 participants on an office task: answering a set of emails as an HR manager, with phone or instant-message interruptions roughly every two minutes, either on the same topic or on an unrelated one.

The results were surprising:

  • Interrupted tasks were completed faster, about 20 minutes vs. about 23 in the uninterrupted condition, with no difference in errors or politeness. People wrote somewhat shorter emails when interrupted.
  • The cost moved elsewhere. In the authors' words: "people compensate for interruptions by working faster, but this comes at a price: experiencing more stress, higher frustration, time pressure and effort."
  • It happened quickly. "After only 20 minutes of interrupted performance people reported significantly higher stress, frustration, workload, effort, and pressure."
  • Context of the interruption did not matter for these measures: same-topic and different-topic interruptions had similar effects.

For engineering work, the lesson is not "interruptions are fine because you speed up". Email replies are short, well-defined tasks. The speed-up came partly from writing less. For a design or a debugging session, writing less and thinking less is the failure mode. And the stress cost accumulates over a day.

5. Attention on screens (Mark, 2023)

In her book Attention Span (January 2023) and in interviews, Gloria Mark summarized two decades of her group's measurements of how long people stay on one screen before switching:

Period Average time on one screen before switching
2004 About two and a half minutes
2012 About 75 seconds
Recent studies (late 2010s onward) About 47 seconds (median about 40)

These measure screen switches, not whole tasks. A developer moving between an editor and a terminal for the same bug counts as switching screens. Still, the trend is clear, and many of those switches are self-interruptions, not external ones. Mark's research also emphasizes that people interrupt themselves about as often as they are interrupted by others.

6. Deep Work (Newport, 2016)

Cal Newport's Deep Work: Rules for Focused Success in a Distracted World (Grand Central Publishing, January 5, 2016) turned these ideas into a professional argument. His "deep work hypothesis": "Deep work is becoming increasingly valuable at the same time that it's becoming increasingly rare. Therefore, if you cultivate this skill, you'll thrive." The book draws on Leroy's attention residue as part of its explanation of why switching is so costly.

Newport describes four ways to schedule depth:

Philosophy How it works Fits engineers who...
Monastic Eliminate most shallow obligations for long periods Rarely fits a team job
Bimodal Alternate whole days (or weeks) of depth with days of availability Can negotiate "focus days" or rotate interrupt duty
Rhythmic Same deep block every day, as a habit Have a predictable morning or afternoon
Journalistic Fit deep work into whatever gaps appear Are experienced at switching in quickly; hardest to sustain

For most engineering teams, rhythmic for individuals plus bimodal at the team level (one person on interrupt duty per day or week) is the realistic combination.

7. Maker's schedule, manager's schedule (Graham, 2009)

Paul Graham's July 2009 essay names the structural problem. The manager's schedule is "embodied in the traditional appointment book, with each day cut into one hour intervals". Makers "generally prefer to use time in units of half a day at least. You can't write or program well in units of an hour."

His key observation: "A single meeting can blow a whole afternoon, by breaking it into two pieces each too small to do anything hard in." His own fix was to hold office hours at the end of the day, so meetings did not cut into maker time.

Combine this with the research above and the mechanism is clear. A meeting at 2:30 does not cost one hour. It costs the anticipation before it, the attention residue after it, and the fact that neither 1:00-2:30 nor 3:30-5:00 feels long enough to start the hard thing.

8. A playbook for engineers

Protect blocks, not hours

Practice Why it works
Two to four hour focus blocks, scheduled in the calendar Long enough to load a problem into your head; visible to others
Cluster meetings on specific days or half-days Fewer fragments; follows Graham's office-hours idea
Team interrupt rotation (an "on-duty" engineer for questions, alerts and support) Turns everyone else's day into a maker's day; bimodal at team level
No-meeting blocks agreed by the team Individual blocks get overridden; shared norms do not
Async by default for questions A question in a channel can wait an hour; a tap on the shoulder cannot

Reduce the cost of each switch

  • Write a ready-to-resume note before every switch. Where you are, what is left, what you were about to try. One minute (Leroy and Glomb).
  • Finish small things under a short deadline before switching. "I will close this review in the next 10 minutes" gives the closure Leroy found useful.
  • Batch shallow work. Reviews, messages and email in two or three fixed windows a day, not continuously.
  • Leave cues in place. Do not close the terminal and editor when you get pulled into a call. Mark's informants lost time partly because their environment had changed by the time they returned.

Reduce self-interruptions

  • Turn off non-urgent notifications during focus blocks, and make urgent paths explicit (pager, a named channel).
  • Keep a "later" list next to you. When the urge to check something comes, write it down instead.
  • Measure, briefly. Log interruptions for one week: time, source, whether it could have waited. Most people find a few sources dominate.

Year-end planning: audit this year, design next year

The last week of December is a good time to look at your calendar with data rather than feelings. Export it, then measure how much uninterrupted time you actually had. This script takes meetings for each day and reports the free blocks that are long enough for deep work:

from datetime import datetime, time, timedelta

WORKDAY = (time(9, 0), time(17, 30))
MIN_DEEP_BLOCK = timedelta(hours=2)
BUFFER = timedelta(minutes=15)  # residue before and after each meeting


def free_blocks(day: str, meetings: list[tuple[str, str]]) -> list[tuple[datetime, datetime]]:
    d = datetime.fromisoformat(day)
    start, end = (datetime.combine(d, t) for t in WORKDAY)
    busy = sorted(
        (datetime.combine(d, time.fromisoformat(a)) - BUFFER, datetime.combine(d, time.fromisoformat(b)) + BUFFER)
        for a, b in meetings
    )
    blocks, cursor = [], start
    for b_start, b_end in busy:
        if b_start > cursor:
            blocks.append((cursor, min(b_start, end)))
        cursor = max(cursor, b_end)
    if cursor < end:
        blocks.append((cursor, end))
    return [(a, b) for a, b in blocks if b - a > timedelta(0)]


def report(calendar: dict[str, list[tuple[str, str]]]) -> None:
    total_deep = timedelta(0)
    for day, meetings in calendar.items():
        deep = [(a, b) for a, b in free_blocks(day, meetings) if b - a >= MIN_DEEP_BLOCK]
        hours = sum((b - a for a, b in deep), timedelta(0))
        total_deep += hours
        spans = ", ".join(f"{a:%H:%M}-{b:%H:%M}" for a, b in deep) or "none"
        print(f"{day}: {len(meetings)} meetings, deep blocks: {spans}")
    print(f"Deep-work time this week: {total_deep.total_seconds() / 3600:.1f} h")


week = {
    "2025-12-08": [("10:00", "10:30"), ("14:00", "15:00")],
    "2025-12-09": [("09:30", "10:00"), ("11:30", "12:00"), ("13:30", "14:00"), ("16:00", "16:30")],
    "2025-12-10": [],
    "2025-12-11": [("09:00", "09:15"), ("12:00", "13:00")],
    "2025-12-12": [("10:00", "11:00"), ("15:00", "16:00")],
}
report(week)
# 2025-12-08: 2 meetings, deep blocks: 15:15-17:30
# 2025-12-09: 4 meetings, deep blocks: none
# 2025-12-10: 0 meetings, deep blocks: 09:00-17:30
# 2025-12-11: 2 meetings, deep blocks: 09:30-11:45, 13:15-17:30
# 2025-12-12: 2 meetings, deep blocks: 11:15-14:45
# Deep-work time this week: 20.8 h

Look at the pattern, not the total. In this example, Tuesday has four short meetings and zero usable blocks, even though it has only two hours of meetings. Moving two of them to Monday afternoon would create a full morning. The 15-minute buffer is a modeling choice, not a research constant: it simply stops a "free" 30 minutes between meetings from counting as focus time.

Then plan next year with three questions:

  1. Which recurring meetings can move, merge or end? Every recurring meeting is a decision someone made once. Review them all.
  2. What is your default deep block? Pick a rhythmic slot (for example, mornings until 12:00, three days a week) and put it in the calendar for the whole year now, before other things fill it.
  3. What team agreements do you need? An interrupt rotation, meeting-free afternoons, an expected response time for chat. Individual discipline does not survive a team culture that expects instant replies.

Why this matters

  • Switching has a hidden cost. Attention residue lowers the quality of the next task, not just the time spent switching.
  • The famous number is shakier than people think. The documented figure is that interrupted work is resumed about 25 minutes later on average, after more than two other activities. That is a reason to protect continuity, not a refocusing constant.
  • Interruptions shift costs to stress. People can compensate with speed, at the price of stress and effort, which accumulates.
  • Structure beats willpower. Calendar blocks, meeting clusters and team rotations work better than trying to concentrate harder.
  • Cheap interventions exist. A one-minute ready-to-resume note is one of the best-supported, lowest-cost habits in the literature.

Final Thoughts

An interrupt-driven job will not become a monastery, and it should not. Answering questions, reviewing code and handling incidents are part of the work. The goal is to stop paying the switching cost on everything, all day.

Pick the hard work that matters, give it blocks long enough to load the problem into your head, put the shallow work in batches around it, and write a short note every time you have to leave a task. Then, this week, look at your calendar from this year and decide what next year's should look like before it fills itself.

Sources