Search

Designing the right to
Designing the right to

Imagine your banking app classifies a meal with friends as a business expense. Or an artificial…

When football decides
When football decides

A few days ago, I tried to access a client’s website from my mobile phone. The browser appeared to…

Innovation is good.
Innovation is good.

Innovation makes headlines. Companies announce new digital platforms, investments in artificial…

Designing the right to correct the machine

Designing the right to correct the machine

Imagine your banking app classifies a meal with friends as a business expense. Or an artificial intelligence assistant bases its answers on information about you that is no longer accurate. Or, simply, a platform keeps recommending products related to a one-off purchase you made months ago.

In all these cases, there is one particular feature: you know the system is wrong, but you do not always have an effective way to correct it.

As digital products incorporate artificial intelligence capabilities, interfaces are no longer limited to carrying out our instructions. They now also interpret information, establish relationships, generate recommendations and make decisions based on their own inferences.

This evolution introduces a new challenge for design in user experience. It is no longer only about making it easier to interact with a system, but also about enabling people to question and correct its interpretations.

Because pressing a “Dislike” button does not necessarily mean making a correction. Removing a recommendation does not mean changing what gave rise to it. And reporting an error does not guarantee that the system will stop making it.

The ability to correct the machine should be part of experience design, rather than an exception within it.

So, what does it mean to design systems that accept corrections? What interaction mechanisms can make this process easier? How can we preserve the capacity for human intervention without turning the user into a permanent supervisor of technology?

From interacting with an interface to negotiating with its interpretations

In a conventional interface, the relationship between the user and the system is relatively direct: we select an option, enter information or carry out an action. The system responds according to previously defined rules.

Intelligent systems introduce a new variable into this relationship: interpretation.

A recruitment platform may infer a candidate’s suitability for a role. A productivity tool may determine which tasks it considers a priority. An e-commerce application may interpret our behaviour as a consumer preference.

In these scenarios, the system constructs a representation of reality that does not necessarily match our own.

From an interaction design perspective, this represents a significant change. We are no longer designing only mechanisms for entering information and carrying out actions, but also for intervening in the conclusions the system draws from that information.

This means incorporating new interaction possibilities:

  • Indicating that an interpretation is incorrect.
  • Providing information the system does not know.
  • Adding nuance to a preference or intention.
  • Questioning a classification or decision.

These interactions should be part of the natural flow of using the product, rather than being relegated to feedback forms or hard-to-find settings.

If the system has the ability to interpret the user, the user should have the ability to intervene in that interpretation.

Interaction design therefore takes on a new dimension: facilitating dialogue between what the machine infers and what the person knows.

Explaining a decision does not mean allowing it to be corrected

Transparency and explainability have become important principles in the design of intelligent systems. However, understanding a decision does not necessarily mean having the ability to change it.

From a user experience perspective, it is useful to distinguish between three concepts:

  • Transparency: enables us to understand what has happened.
  • Explainability: enables us to understand why it has happened.
  • Ability to correct: enables us to intervene in what has happened.

Imagine a learning platform that adapts its recommendations to the user’s level of knowledge. The system may report that it has assigned them a beginner level and explain that this classification is based on their recent activity. But what happens if that activity does not reflect their actual knowledge? Can the user change their level or provide additional information?

In this example, the product may be transparent and offer an understandable explanation, yet still be unable to deal with a discrepancy.

The challenge is to connect the explanation with an opportunity to act. The information provided by the system should help the user identify what they need to correct and offer an appropriate mechanism for doing so, either through a direct amendment or by requesting a review.

Transparency without the ability to intervene can turn the user into a mere spectator of decisions that affect them.

Therefore, when designing an intelligent interface, we should not only ask how to explain the system’s decisions, but also what the user can do when they disagree with them.

The different levels of correction

Not all corrections address the same need. Sometimes the user wants to change a specific result; at other times, they need to intervene in the information that generated it or in the system’s future behaviour.

From an interaction design perspective, we can distinguish five levels of correction:

Level

What is corrected

Example

Result

An answer or classification.

This expense is personal, not business-related.

Context

The information used by the system.

That person no longer works with me.

Inference

A conclusion drawn by the system.

The fact that I look at hotels does not mean I want to travel.

Behaviour

A pattern of future action.

Do not use this information to personalise my recommendations.

Decision

An automated determination.

I do not agree with this assessment and request that it be reviewed.

This distinction is important because each level requires different interaction mechanisms.

For example, correcting the category of a banking expense resolves a one-off error. However, if the system continues to classify similar expenses incorrectly, it may be necessary to change the criterion it uses to make that classification.

We must also distinguish between a one-off and a persistent correction. We do not always want a change to become a permanent rule. An exception should not automatically be interpreted as a new preference.

In the case of automated decisions, moreover, correcting does not necessarily mean being able to change a determination directly, but having mechanisms to challenge it, provide information and request a review.

Correcting a result does not always mean correcting what generated it.

Identifying these levels allows us to design more precise intervention mechanisms and offer the user control proportionate to their needs and to the scope of each correction.

Design patterns for systems that accept corrections

Designing for the ability to correct means translating this principle into specific interaction mechanisms. There is no single valid pattern for every scenario: the choice will depend on the nature of the error, the context of use and the consequences of the decision.

Some patterns we can incorporate into the design of digital products are:

  • Direct editing of results. Allowing an answer, label or classification to be changed without leaving the context in which it is presented.
  • Contextual feedback. Enabling the user to indicate what is incorrect and why, rather than merely expressing satisfaction or dissatisfaction.
  • Correcting inferences. Making certain system assumptions visible and allowing the user to validate, qualify or reject them.
  • Adding further context. Offering the possibility of adding relevant information that the system has not taken into account.
  • Selecting the scope of the correction. Allowing users to decide whether a change affects only the current result or future interactions as well.
  • Confirming the effects. Communicating what has changed following the user’s intervention and what consequences that change will have.
  • Challenging decisions. Providing accessible mechanisms to request a review when a determination cannot be changed directly.

A particularly interesting example is the use of thumbs-up or thumbs-down buttons, common in artificial intelligence interfaces. Although they are useful for gathering signals of satisfaction, a thumbs-down does not necessarily communicate what is wrong, what should change or how the user expects the system to behave in future.

There is, therefore, a fundamental difference between designing mechanisms to gather feedback and designing mechanisms to manage corrections.

Feedback tells the system that there is a problem; correction makes it possible to intervene in it.

The aim should not be to fill interfaces with new controls, but to incorporate relevant intervention mechanisms at the time and place where the user needs them.

Correcting should not become working for the machine

Giving users the possibility to correct an intelligent system does not mean transferring to them the responsibility for ensuring that it works properly.

If a productivity tool requires us to constantly review its classifications, rephrase instructions or correct the same errors, some of the efficiency it promised disappears. The time we gain through automation may end up being spent supervising it.

From a user experience perspective, it is worth paying attention to four aspects:

  • Cognitive load. Correcting should require less effort than manually performing the task we intended to automate.
  • Persistence. The system should respect previous corrections when the user has indicated that they should apply to future interactions.
  • Proportionality. A simple correction should not require the same effort as reviewing a complex decision.
  • Responsibility. The possibility of intervening does not relieve the product of responsibility for the quality of its results.

It is also useful to measure the cost of correction as an indicator of experience quality: how many times the user must intervene, how much time they spend resolving errors and how often problems they have already corrected reappear.

These metrics can reveal shortcomings that traditional satisfaction or performance indicators do not always detect.

Giving the user control is not the same as requiring them to provide constant supervision.

A good experience should allow us to intervene when we consider it necessary, without forcing us to do so continuously for the system to work properly.

Designing correction as part of the product

The ability to correct should be considered from the earliest stages of designing an intelligent product, with the same importance as other aspects of user experience, such as accessibility, usability or error prevention.

To achieve this, UX, development and product teams can incorporate some questions into their design and validation processes:

  • Can the user identify that the system has made an incorrect interpretation?
  • Do they have an accessible mechanism for correcting it?
  • Do they understand the scope and consequences of their intervention?
  • Can they verify that the correction has been applied correctly?
  • What happens if the system makes the same error again?
  • Is there an alternative way to request a review when it is not possible to change a decision directly?

These questions should also be incorporated into usability testing. In addition to evaluating whether a person can complete a task when the system works correctly, we should observe what happens when it makes an incorrect interpretation.

Deliberately introducing errors or incorrect inferences into test scenarios can help us identify interaction problems that would go unnoticed under ideal conditions.

This also requires close collaboration between design and development. There is little point in offering a correction mechanism if the product architecture does not allow its effects to be applied, retained or verified.

The ability to correct should be a product quality criterion from its conception, not a feature we add when the first errors appear.

Designing for intelligent systems means accounting for both their successes and their mistakes, and building experiences capable of managing both scenarios.

Conclusion

The evolution of digital products places us in a scenario where machines not only carry out our instructions, but also interpret reality and take part in decision-making.

The greater their capacity to do so, the more important it will be to preserve our capacity to intervene.

Designing the right to correct the machine does not mean distrusting technology or giving up the benefits of automation. It means recognising that the system’s knowledge has limits and that people may have information, experiences and knowledge that the machine does not possess.

Perhaps we should also broaden the way we assess the quality of intelligent products. We should not value only their ability to get things right, but also how they respond when someone challenges their conclusions.

The quality of an intelligent interface should not be measured only by what it can do, but also by its ability to accept that it is wrong.

Become a member

Get the latest updates straight to your inbox. No spam.

What use is an intelligent interface if, when it makes a mistake, it does not allow us to correct it?

Comments
Comment