Applying Usability Heuristics to Animal Crossing: New Horizons

Exploring how New Horizons prevents errors through the lens of the 10 usability heuristics

Maria Meireles
Published in
12 min readJan 3, 2022


In this series about the 10 usability heuristics, I have covered four heuristics on four different games:

This article is about Animal Crossing: New Horizons and the fifth heuristic: error prevention. Prevent problems from occurring by eliminating error-prone conditions or presenting the option of confirming if users want to do the action or not.

I will talk about the different solutions Animal Crossing: New Horizon uses to prevent user errors and how error prevention enforces a sense of enjoyment and helps take one’s mind off while playing.

Source: Nintendo

Error Prevention

Systems should eliminate error-prone conditions or inquire if the user really wants to perform the action. Good error messages are extremely important, but before an error even occurs, we should think of preventing them.


Errors can drive users away from systems. Especially if they keep occurring — even if a message, an explanation, or solution is presented. The user might feel like something wrong was done. The blame for the error can be a sensitive subject.

As we design systems, games or any other object, we need to keep this in mind (even if it might not be 100% true): users don’t make mistakes on purpose; we make them too easy to happen. It’s our job to check for potential errors and avoid needing to provide feedback on an error. Avoid saying “try later” or provide more training. We should design systems with user errors in mind.

Types of Errors

There are two types of errors:

(1) Slips: This usually happens when users are on auto-pilot or are not giving full attention to the task. They already know this task too well and allocate less focus to it. When they intend to do one action but perform another action, even if they know how to reach their goal and even if the system is correctly designed for it to happen.

Example: Ruining an entire set of light clothes because when you were selecting the set of clothing, you let a recently bought black t-shirt slip into it; typing errors because the letters are close to each other on the keyboard.

(2) Mistakes: This occurs when users do conscious errors. They perform what they think it’s the correct task/action to reach their goals, but in reality, it’s not. Here, even if they are paying attention, the task will cause an error. One reason is usually due to incomplete or incorrect information about the task.

Example: Using the wrong laundry machine program for your clothes because your new machine does not have text labels for the programs, only icons and you misinterpret them.

Source: Gamerant.

How can we prevent errors?

We have two types of errors with different problems. Before going into the different things you can do, the first tip is to prioritize effort.

Analyze your system and check for potential slips and mistakes. Start by addressing the ones that have a bigger impact until you reach the low-impact ones. You should prioritize an error that can cost a lot of money or completely ruin your system over minor frustrations. Sometimes you should even allow or let errors happen. Analyzing the level of impact and its importance on the user’s journey and tasks is key to making the right design decisions.

Solutions for these vary according to the types of errors. For slips, think of ways in which the user might make errors if it’s not paying attention. One good tip is to pretend it’s early in the morning when you are testing your system. Be forgiving. Include constraints that help the user enter data (for example, only allowing number input if only number input is needed), offer suggestions and use good defaults. If you know your user well, you can predict what they might want to do in a specific task. A simple suggestion of completion or default that not only speeds up their job, but it’s the most probable to be used helps slips to be avoided.

For mistakes, the solution looks similar but demands more extensive knowledge of your user. If you understand your user, you can learn their mental models and use patterns and solutions that they already know or are used to (follow the 4th heuristic!). Saying this is also important to communicate clearly what is possible to do with your system, what every bit and piece does and let users know the result of an action. In this way, not only is the path clear, but the goal is also straightforward. Even if they were performing the wrong task for their goal, they will have enough tips and knowledge to correct their path.

Of course, there is a middle ground, how to prevent both:

(1) Display contextual information to avoid memory lapses or the burden of too much information to be memorized:

When selecting the engine class in Mario Kart you can already preview the rewards earned in each cup with help of the trophy with a representative image of the cup and the stars earned below. Source: Nintendo.

(2) Confirmation dialogues to confirm destructive actions. However, use it wisely and with scarcity when the action will destroy something that took time to create or might have big implications;

In the middle of a race you can exit by entering the instructions menu & selecting Exit (in image: “Sair”). Source: Nintendo.
But clicking Exit (“Sair”) will open a confirmation modal — Are you sure you want to exit? (“Deseja mesmo sair?”). Source: Nintendo.

(3) Support undo action as a safety net in case of a slip. Users will feel safer performing their tasks as a result:

While selecting the race setting — the type of race, engine class, character, vehicles parts and cup — players can go back and forth on the different selections screens to change their selection. Source: Nintendo.

(4) Warn the player of a potential error that is being made before it happens. Contextual warnings will help users correct errors quickly and prevent a bigger impact due to the error.

This one is not exactly an error, but after selecting everything the player clicks ‘OK’ and a giant button with another ‘OK’ appears on the screen. After clicking on the second “OK” the player can’t go back. The cup will start and if the player leaves it goes back to the beginning. Source: Nintendo.

The key to error prevention is to understand the user and its journey. What are their goals? What do we want to give to users? And what slips or mistakes can happen that we want and can avoid?

Source: Nintendo.

Animal Crossing: New Horizons Simulates Paradise With Challenges and Forgiveness

Animal Crossing is a social simulation video game series published by Nintendo. Animal Crossing: New Horizons is the fifth game in the series where the playable character lives on a tropical island that is inhabited by anthropomorphic animals. It is possible to plant, fish, catch insects among other activities.

There are no clear objectives, but the player is motivated to perform the activities available. Besides the basic activities, new activities are unlocked as time passes and as the player continues to explore the contents of the game. In addition, there are activities that vary with the time of year or updates.

Customization is one of the great incentives to carry out activities.

With the materials or money gathered, it is possible to customize both the island’s space, the character’s house, and their outfit. Several other customization elements appear from the beginning or keep appearing, allowing the player to have a feeling of control in the construction of their paradise island. Not only does the player have control of its appearance, but who inhabits it and its government. Even the communication with other players and friends is controlled by the player and allowed as they wish.

The game’s mood is relaxing — the colours are light and bright, the music is calm but lively, the sounds transporting you to a peaceful place surrounded by nature.

So how does UX helps simulate this paradise and sense of control?

Simulate paradise with challenges and forgiveness

It is a simple concept but a complex design work — if you are going to allow players to do almost anything, you also should be aware of potential errors and prevent them.

My general example was Mario Kart, which does this straightforwardly. There aren’t many actions or slips to help with. We already have road barriers to prevent falls (most of the time), but Animal Crossing demands more work as it has a lot more actions available.

I already talked about how we can prevent errors. Now it’s time to see how that was accomplished in Animal Crossing. Here are some examples:

(1) Prioritize effort
There’s a clear focus of effort on tasks that have a more destructive effect. Throw away, give money (example: buy or deposit), and craft are actions that can have a negative impact as they all reduce materials or money. When a user selects one of these actions, a confirmation is always requested.

(2) Constraints that help the user enter data (for slips)
All dialogues have a set of actions that can be performed. If the input of money is needed, users can select only numbers, delete all numbers, delete one by one, have access to an accelerator that selects the full amount available, and a confirm.

Screen to deposit money. Source: Author.

(3) Offer suggestions and good defaults (for slips)
The game offers some suggestions, for example, when buying fruit. When you select cherries to buy you can select from three actions: buy one, buy five (since it is common that players will use more than one at a time) or give up on that purchase (it’s possible to cancel the action, as you can see by the sign on the bottom right of the screen).

The suggestion to buy five is an excellent example of a good default. It offers a reasonable number of cherries, a balance between the effective amount, and a reasonable cost.

Buy cherries dialogue screens. Source: Author.

(4) Follow standard design conventions (for mistakes)
Animal Crossing not only follows design conventions, but some of its interactions are closer to a real-life application that most users are familiar with, but is simplified. This makes sense since it replicates tasks and interactions that exist in the real world. You can look at both of the previous screens and remember real-life applications that look like it. The first resembles an ATM, and the second is a list of items to buy with image representation and cost.

(5) Communicate affordances (for mistakes)
An affordance is a way in which we can interact with the object. We can achieve this by communicating the signifier of the affordance — the use of visual cues. In the example below, we can see a screen to buy items. The different ways you can interact with it are good examples of well-designed signifiers. The affordance is communicated clearly.

On the top, a component with several icons indicates the navigation for the category of the items. To navigate through categories, the user must use the L and R buttons. L indicating left is on the extreme left of the navigation component (press L to go left), R indicating right is placed on the extreme right of the component (press R to go right).

Screen to buy clothing. Source: Author.

(6) Preview Results (for mistakes)
Letting users know the results of an action can not only make them backtrack in case said action has a significant impact, but also assures them they are performing the task correctly by comparing the result of the action with their goal.

In Animal Crossing, we can see two excellent examples of this. The first example is with the game’s currency. Every time there’s a transaction, both the amount of what something costs and the total amount owed are always on screen. In the two images above, you can see the cost of each item, how much you will spend, the money you currently have and, after selecting to buy, a confirmation modal with the total amount spent on the item.

The second example is with the game’s materials. On the image below, you can see not only the result of the action, the item itself (Flimsy axe), but also the material spent to craft it.

Crafting a Flimsy axe. Source: Author.

(7) Remove Memory Burdens
Displaying contextual information helps users complete tasks without the burden of memorizing a lot of information.
We can see this using the example above: the crafting screen. When you are crafting an item, you have access to some of the most important information about it: name, favourite state, size, materials and material amount (have/need), if you previously crafted it, if you already have one on your pockets, if you already have one on your storage.

This is also a good example of how a game can provide useful information to players. In the image above, I see I don’t have a Flimsy axe in my pockets or in storage. On the image below, I can see I have a Flimsy fishing rod in storage.

I can craft two Flimsy fishing rods. It only requires five tree branches (I have 10). I can’t craft an axe, however, even if I only need five tree branches. I’m missing a stone. I might want to save those five tree branches. I can decide to craft a Flimsy axe in the future (after gathering a stone) instead of crafting two Flimsy fishing rods because I have all the materials I need to do so.

All of this contextual information allows me to make a decision before spending the materials I have or having to go back and check (and memorize this data).

Craft a Flimsy fishing rod. Source: Author.

(8) Confirm Before Destructive Actions
As mentioned in my first point, there is a selection of actions that have confirmation before completing said action. In these groups, destructive actions are included or actions that might decrease your amount of money or materials (except if it’s a direct action in the world, like when an item reaches its limit of use, it breaks).

The example of confirmation dialogue before throwing away a letter is straightforward, as you can see in the image below.

Clicking on “-” to Throw Away (bottom right of the screen) will open a small confirmation dialogue to select between Throw Away again or Keep. If you select Favourite, Back or Present, the actions have an immediate effect without confirmation.

Throw away a letter. Source: Author.

(9) Support Undo
While undo itself is not directly possible, it is allowed to cancel a task. Almost all dialogues or screens of tasks have cancel/close/back or action inside the dialogue with the list of actions.

Cancel the option on the bottom of the right screen to leave the task (buying shrubs and flowers from Leif) and “Never mind” on the list of actions, to leave the dialogue. Source: Author.
Close screen option on the bottom right of the screen. Source: Author.
Go back to the previous step — on the bottom right of the screen. Source: Author
“Sign off” from the machine as the last option of the list of actions. Source: Author.

(10) Warn Before Errors Are Made
Contextual information can also come in a form of a warning. In most cases, it happens when a user is performing an action and is subtly informed of an error (for example, the classic red line below a grammatical error).

Animal Crossing: New Horizons does not do this. It lets users select the action and try before showing an error message that looks like an information dialogue (check the image below). It’s a decision that follows this idea of paradise and existing in a perfect place. The game runs away from showing classic errors, contextual or not. Sometimes, an action could be blocked in a more subtle way, but this solution provides an opportunity to teach why this action is not available.

Dialogue that pops up when you try to throw away a letter with a present. Source: Author.

Final Thoughts

Animal Crossing: New Horizons is built to make us dream. Here we live in the perfect world built by us, for us. The colours are bright; activities are mostly linked to nature; the characters are full of personality, and we are constantly listening to a relaxing soundtrack in the background. It’s impossible not to feel a sense of peace as you play.

Being able to customize almost anything to build this perfect life gives players a sense of control over their own lives that is hard to achieve in reality. Especially in times like these — which marked the launch of Animal Crossing: New Horizons — the contrast is further stressed. The outside world, changing week to week with pain, uncertainty and restriction; the world of Animal Crossing with joy, music and community.

Preventing errors is an important part of creating a sense of control and perfection, error becoming minimized to the direct interaction with the world. The player is taught rather than “punished” and new activities and events can be created with the certainty that these “floats” will ensure a wholesome experience.