Human error and user-interface design From Chapter 22, Handbook of Human-Computer Interaction

This post is part of a series of notes I collated during my studies at UCL’s Interaction Centre (UCLIC).

“To err is human, to forgive is the role of the computer interface.”

“If an error is possible, someone will make it. The designer must assume that all possible errors will occur and design so as to minimise the chance of the error in the first place, or its effects once it gets made. Errors should be easy to detect, they should have minimal consequences and, if possible, their effects should be reversible.” (Norman, 1988)

Classifying human error

Error can be defined in terms of either the action or the consequences of the action.

Errors cannot be defined by considering human performance in isolation, but have to be defined in reference to human intentions or expectations. (Rasmussen, 1982)

Human error categories

Slips and mistakes

Norman (1981) identified two important distinctions for human errors:

  • Slips are failures of execution – the plan for the action may be correct, but the actions do not go as planned.
  • Mistakes are planning failures – the action may go as planned, but the plan itself is wrong.

Rasmussen (1986) proposed a three-level hierarchy:

  • Skill-based – behaviour that is without conscious control.
  • Rule-based – behaviour that is with conscious control, in familiar situations, using stored rules or procedures.
  • Knowledge-based – behaviour that is exhibited in unfamiliar situations.

Reason (1990) identified three basic error types within Rasmussen’s hierarchy:

  • Skill-based slips – errors at this level arise from speed-accuracy trade-offs, intrinsic variability of the human operator, capture by motor schemata etc. Errors occur due to fallibility in perception, attention, memory or execution.
  • Rule-based mistakes – errors at this level involve failures in the selection or application of problem-solving rules. Errors occur due to application of wrong rules, incorrect recall of rules, reliance on an under-specified cue set and interference from familiar rules.
  • Knowledge-based mistakes – errors at this level arise due to the “trial and error” learning involved in novel situations. Errors occur due to the hypothesis testing process, resource limitations or interference in functional reasoning due to false analogies.

Cognitive control and systematic error mechanisms

Rasmussen and Vicente (1987) propose an error taxonomy:

  1. Errors related to learning and adaptation.
  2. Errors due to interference among competing cognitive control structures.
  3. Errors due to lack of resources.
  4. Errors due to intrinsic human variability.

Error capture and recovery

Lewis and Norman (1995) propose that the effort should be to maximise the discovery of error (error capture), to make it easier to recover from error (error recovery), and to minimise the incidence of error.

Possible system responses:

  • Gag – prevent the user from continuing.
  • Warn – e.g., beeps, text messages.
  • Do nothing – e.g., clicking on a disabled control provides no visible change.
  • Self-correct – e.g., word processor auto-correct function
  • Let’s talk about it – the system responds by initiating a dialogue with the user, e.g., co-operative problem solving.
  • Teach me – the system asks for further clarification.

Error messages – a useful error message is one that not only tells the user what went wrong, but also provides some information on how to take the right action (remedial information).

Feedback – feedback on the effects of actions should be provided to the user. Such feedback facilitates error recovery by supporting functional understanding and also helps knowledge-based monitoring.

Error reduction: issues and guidelines

Rasmussen and Vicente (1987):

  • Interface design should aim at making the limits of acceptable performance visible to the users, while the effects are still observable and reversible.
  • Provide feedback on the effects of actions to allow the user to cope with the delay between the execution of an intention and the observation of its effect.
  • Make overview displays available to avoid capture errors at the skill-based level.
  • Support memory with the externalisation of the effective mental-models.
  • Develop consistent information transformation concepts for data integration to enable the interface to present information at the level that is most appropriate for decision-making.
  • Support of memory items, acts and data, which are not part of the integrated “gestalt”, can be useful.

Interface design principles that can be applied to minimise the consequences of human error include:

  • Ensure consistency across interfaces.
  • Provide good conceptual models or metaphors.
  • Reduce or account for mode, capture or description errors.
  • Provide visibility through affordances.
  • Provide appropriate constraints and mapping.
  • Reduce the gap between the gulf of execution and the gulf of evaluation.
  • Provide appropriate communication and feedback.
  • Facilitate multiple activities.
  • Understand cultural biases.
  • Use colour.
  • Provide online help.

Designing for error tolerance

Interfaces should be error tolerant, i.e., allow for errors but minimise their effect.

Senders and Moray (1991) suggest that eliminating the opportunity for error severely limits the range of possible behaviour and thus inhibits trial and error learning, which is helpful in discovering new ways to perform tasks. They argue that the key is to reduce the undesirable consequences of the error, not necessarily the error itself.


Human error cannot be separated from human performance.

Errors are part of the learning process and as such systems/interfaces should be designed to be error tolerant.

It should be possible for the user to explore the system without penalty, discover what the consequences are for different actions and be able to recover from those consequences.

Wherever possible, the system should capture error at the earliest feasible instance and provide the user with a feedback that is specific and useful in correcting the error.

References and further reading

  • Prasad V. Prabhu, Girish V. Prabhu, (1997) Chapter 22 - Human Error and User-Interface Design, Editor(s): Marting G. Helander, Thomas K. Landauer, Prasad V. Prabhu, Handbook of Human-Computer Interaction (Second Edition), North-Holland, Pages 489-501, ISBN 9780444818621.

Updated on: 10 February 2021

Are you building something interesting?

Get in touch