Two tasks drawing on the same resource interfere the most
Aliases: resource overlap · psychological refractory period · PRP · dual-task cost
What it is
When two concurrent tasks compete for the same kind of processing resource — the same sensory input channel, the same response modality, the same mental code (both requiring verbal recoding, say) — they slow each other down far more than a pair of tasks drawing on different resources. This is the most robust finding in dual-task costs: the amount of interference tracks resource overlap, not just task difficulty on its own. Two individually trivial tasks can still slow each other noticeably if they compete for the same resource.
Why it happens
The source of interference is not a vague "the brain is too busy" — it is a concrete structural bottleneck: some processing stage or output channel can only serve one task at a time, forcing the other to queue.
The clearest evidence comes from the psychological refractory period (PRP) paradigm: two stimuli arrive close together, each requiring a decision and a response, and the response to the second one is measurably delayed. That delay is much larger when both tasks share the same response channel (both requiring a right-hand keypress, say) than when the responses are split across channels (one hand, one foot; or a keypress and a spoken response). The more completely the resources overlap — same sensory channel, same response effector, same code, stacked together — the longer the queue and the higher the behavioral cost.
Studying it
The dominant paradigm is PRP: manipulate the stimulus onset asynchrony (SOA) between the two tasks and observe how much the second task's reaction time grows as SOA shrinks; then compare that growth across different overlap conditions (same channel vs. cross-channel, same effector vs. cross-effector, same code vs. cross-code), typically plotted as paired performance operating characteristic curves.
Typical independent variables: the degree of overlap between the two tasks along sensory channel, response effector, and mental code. Typical dependent variables: the reaction-time cost to the second task, accuracy changes, and the trade-off between the two.
In interface research, this method is mainly used to ask whether users can genuinely do two things at once — for example, whether voice interaction and manual input truly run in parallel or are still queuing behind the scenes.
Methodological caveat: lab PRP tasks are highly simplified, controlled keypress responses; real interface tasks vary in complexity, time pressure, and practice. The direction of the effect (more overlap, more interference) is robust, but the specific time costs from the lab should not be transplanted directly onto real scenarios.
Where it stops holding
- When both tasks are simple enough to be near-automatic, the interference from resource overlap drops sharply and can become hard to detect — practice changes the cost, it does not remove the underlying bottleneck.
- Explicit priority instructions (telling users which task to finish first) change how the cost is distributed between the two tasks; the cost can be shifted, not made to disappear.
- Extensive practice can shrink the strategic, non-structural portion of the cost, but it cannot eliminate the structural bottleneck itself — two tasks sharing a channel will always queue, only the queuing efficiency can improve.
- This conclusion rests on tightly controlled laboratory dual-task paradigms; real interfaces have blurrier task boundaries and dynamically shifting priorities, so measured costs there tend to be noisier than the lab numbers.
Applying it
- When users must handle two tasks at once, avoid stacking them on the same resource: don't require two simultaneous fine manual actions, and don't route two time-critical pieces of information through the same sensory channel at once.
- In high time-pressure settings (driving, monitoring), reserve the critical resource for the primary task and compress secondary information into a low-resource-demand form (a simple tone rather than text that needs reading).
- Don't rely on "users will get used to it" to resolve a structural conflict — practice lowers the cost, but as long as two tasks compete for the same channel, the cost never reaches zero.
- Verification: run a dual-task test — measure task A alone, task B alone, then both together, and compare the reaction-time and error-rate increase against the single-task baseline. The larger the increase, the more the pair overlaps in resources and the more it should be split apart.