Catching your own mistake is cheaper to fix than having the system catch it for you

What it is

When a user catches their own error, correcting it is usually far cheaper than waiting for the system to detect it and flag it: the user already knows what they were trying to do and where it went wrong, so the correction can pick up right where the original intention left off. An error the system flags instead requires pulling the user's attention back from the current task, parsing what the prompt is saying, and relocating exactly where the error happened — a whole extra round of reorientation on top of the fix itself. Self-discovery is cheap not because it happens faster, but because the person who discovers it already holds all the background needed to fix it, with nothing to reload.

Why it happens

While carrying out an action, a person holds a representation of what the result is supposed to look like. If the actual outcome diverges from that representation in a perceptible way, the mismatch registers almost instantly, because both sides of the comparison — expectation and reality — are already sitting in the same working memory, with nothing extra to retrieve. A system prompt, by contrast, injects a new piece of information from outside: the user first has to figure out what the prompt is saying, which specific action or location it refers to, and which of their own recent actions it maps back to. That translation step itself costs time and attention, and it gets worse the further the prompt lags behind the actual mistake — the user may even need to reconstruct what they did just to make the connection.

Studying it

A typical experiment comparing correction time between self-detection and system prompting has participants complete a task with pre-planted errors, where one group's errors are only found through their own observation and another group receives a system prompt after the error occurs; the study then records the time and number of steps between the error occurring and its successful correction. Methodological caveat: in real use, when an error gets noticed is inherently variable, whereas lab studies artificially fix the "prompt delay" variable for comparability. That artificial delay may not reflect the actual detection lag a real system produces, so the external validity of any comparison needs to be read against the product's genuine detection latency.

Where it stops holding

This conclusion assumes the error is perceptible in the first place — if it leaves absolutely no observable trace, the cost advantage of self-detection is moot, because the user never registers a need to fix anything. It also weakens when consequences are cumulative or delayed — an error made now that only surfaces much later. Even if such an error is perceptible at the moment it happens, the user may not register the current state as "wrong" precisely because the consequence hasn't shown up yet, and the delayed consequence stretches out the window during which self-detection could occur, eroding its cost advantage.

Applying it

Favor giving an action's immediate result enough information on its own to make the gap between expectation and reality visible, rather than relying on the user to actively check or wait for a system to validate it afterward. To judge whether an action already meets this bar, cover up any follow-up prompt the system would give and look only at the interface change at the instant the action occurs, then ask: from this change alone, with no prompt in sight, can the user tell the result isn't what they wanted? If the answer is no, this action lacks the direct feedback self-detection needs, and that gap should be closed first, rather than parking all responsibility for catching errors in a system check that fires after the fact.

Related

• Same group: A10.15.2 error detection depends on a clear sense of the expected outcome, and errors are harder to notice under fuzzy goals · A10.15.3 the longer the gap between action and feedback, the lower the odds a user detects their own error · A10.15.4 systems should prioritize supporting self-detection rather than handing detection entirely to system validation
• Nearby: A10.08 error tolerance and graceful degradation · B2.06 feedback
• Search terms: self-detected error · error correction cost · feedback