Context-switching cost is the aggregate cognitive expense of transitioning between tasks or projects, encompassing three distinct components. First, attention residue: the persistence of the previous task's unresolved elements in working memory, degrading performance on the new task. Second, constellation disassembly: the destruction of the assembled cognitive state (populated working memory, configured executive control, invested emotional attention) that deep engagement had built. Third, reassembly cost: the time and resources required to rebuild the constellation for the resumed or new task. Together, these components constitute the full tax that the AI-augmented builder pays at every transition between projects. The costs are non-trivial individually and multiplicative in combination: a builder switching thirty times per day pays the tax thirty times, and because residue accumulates across switches while recovery opportunities are scarce, the effective cost of the thirtieth switch is substantially higher than the first.
The cost is hidden by several factors. First, it's distributed across time: the residue generation occurs at the moment of switch, but the performance degradation appears during the subsequent task. The disassembly cost is experienced as the end of one work session; the reassembly cost is experienced as the start of the next. No single moment contains the full cost in a form that makes it salient to the builder or observable to managers. Second, the cost is often below the threshold of conscious awareness — the builder feels busy and productive while her judgment is measurably degraded. Third, conventional productivity metrics capture the outputs produced despite the switching costs but not the quality degradation those costs induced. An organization tracking features shipped per builder per week sees the multiplication that AI enables but not the judgment impairment that the multiplication required.
AI tools transform context-switching from an occasional cost to a structural feature of the work. Pre-AI knowledge workers switched between tasks, but the switching frequency was constrained by production pace. Writing code took hours; drafting documents took days; building analyses took weeks. The production bottleneck created extended periods of single-task engagement between switches. AI eliminates the bottleneck: code generation takes minutes, documents draft in hours, analyses build in an afternoon. The acceleration means there's always another output awaiting evaluation, another project demanding attention, another context to switch to. The frequency of switching increases, and because recovery opportunities (genuine disengagement periods) are colonized by task seepage, the residue from each switch accumulates rather than clearing.
The cost structure differs from other organizational costs in a critical way: it scales superlinearly with the number of switches. The first switch of the day incurs a base cost (residue generation, disassembly, reassembly). The second switch incurs the same base cost plus the additional cost of operating under residue from the first switch. The third switch operates under residue from two prior switches. By the thirtieth switch, the builder is carrying a compound residue load that makes every component of the switching cost more expensive: disassembly is harder because more elements must be dismantled, reassembly is slower because working memory is already partially occupied, and the generated residue is denser because the constellation being abandoned was never fully assembled in the first place. The cost isn't linear in the number of switches; it's a curve that steepens as switching frequency increases.
Organizations can measure context-switching costs through proxies that existing systems already track. Defect rates per line of AI-generated code can be correlated with the number of context switches the approving engineer performed before approval. Strategic pivot frequency can be correlated with the switching load of the executives who made original strategic choices. Time-to-productivity for new engineers can be analyzed to separate inherent onboarding difficulty from the context-switching overhead that the engineering workflow imposes. These correlations won't have the precision of Leroy's controlled experiments, but they'll be suggestive enough to inform design decisions: whether to assign builders to fewer projects, whether to batch evaluations, whether to protect focus windows, and whether to measure judgment quality alongside output quantity.
The concept integrates findings from multiple research traditions: attention residue (Leroy), task-set reconfiguration (Monsell), interruption costs (Mark), and working memory dynamics (Baddeley). The specific three-component decomposition — residue, disassembly, reassembly — clarifies that 'switching cost' is not a single expense but a compound tax paid at multiple stages of the transition. The framework's application to AI-augmented multi-project work recognizes that switching has become the dominant mode of operation for AI-era knowledge workers, converting what was an occasional cost into the structural overhead determining whether productivity gains are genuine or illusory.
Three-component tax. Switching costs include residue generation (degrading the next task), constellation disassembly (destroying the current state), and reassembly (rebuilding for the next task) — each expensive, compounding in combination.
Superlinear scaling. Cost increases faster than the number of switches because each switch operates under accumulated residue from prior switches, making disassembly harder and reassembly slower.
Hidden from metrics. Productivity dashboards capture outputs despite switching costs but not the judgment degradation those costs produce, creating systematic misalignment between measured productivity and actual quality.
Design-addressable. Unlike inherent task difficulty, switching costs are reducible through workflow design: sequencing projects, batching evaluations, protecting focus periods, and reducing the number of simultaneous projects per builder.