10 Nielsen heuristics: how to find critical errors in any interface in an hour

Jacob Nielsen formulated his 10 heuristics in 1994. Thirty years later, they work because they describe the fundamental principles of human-system interaction rather than specific UI patterns.

For an hour of bypassing the product through the heuristic lens, you can find most of the critical usability problems. Not all, but the most expensive for sure.

## How to use this article

For each heuristic: definition, examples of violations, examples of a good decision, and a specific checklist for verification. At the end – the prompts for AI-evaluation through screenshots.

No need to memorize all 10 by heart. You need to understand the principle behind each - then the violation is noticeable by itself when working with the interface.

## Heuristic 1: Visibility of system status

**The user should always know what is going on. The system informs the current state after a reasonable time.

** Violations:**

• The button is pressed - nothing has changed. Download? Mistake? I don't understand
• File downloads, but no progress bar - only spinner
• Form sent, page updated - but there is no confirmation that everything passed
• AI agent works – there is no process indicator

Well done

• The button changes state after pressing ("Save" → "Save..." "Retained ✓"
• Progress bar with real progress when downloading a file
• Breadcrumbs show where you are in multi-step flow

** Checklist:**

• Each action has a visible reaction within 1 second
• Processes longer than 1 second show a load indicator
• After completion of the action, there is a clear confirmation
• Active navigation element visually highlighted
• The form shows what is sent (and what will happen next)

## Heuristics 2: Correspondence of system and real world

*The system uses the user language, not the internal language of the developers. It follows real conventions.

** Violations:**

• "Debugger" in the interface for non-technical audience
• “Essence”, “instant”, “recursion” in UI for ordinary users
• Icons that don’t match their functions (the home icon opens settings)
• Metaphors that don’t work for the target audience

Well done

• Financial product uses accounting terminology, not programming
• Icons correspond to established conventions (garbage basket = delete, envelope = letter)
• The “Order” button in e-commerce, not “Confirm Transaction”

** Checklist:**

• All terms are clear to the target audience without explanation
• Icons correspond to generally accepted values n
• UI metaphors are familiar to the audience (folders, basket, mail)
• There are no technical terms where the audience is non-technical

## Heuristics 3: User control and freedom

Principle: Users often choose functions by mistake. You need an "emergency exit" - the ability to cancel or redo without a long process.

** Violations:**

• Remove button without confirmation and without possibility to restore
• “Back” in the browser loses the completed form
• Multi-step flow without the ability to return to the previous step
• Subscription that cannot be cancelled on its own

Well done

• “Undo” for any destructive action (or a recovery basket)
• Form saves data when moving back
• Confirmation dialogue before deletion with explanation of consequences
• "Cancel" is always available and it is clear where it leads

** Checklist:**

• Destructive actions have confirmation or undo
• "Back" works as expected and does not lose data
• It is possible to get out of any flow without consequences
• Deleted data can be restored (basket or undo)
• A wrongly started process can be interrupted at any time

## Heuristic 4: Consistency and standards

**The user should not think about whether different words, situations or actions mean the same thing.

** Violations:**

• In one place “Save”, in another “Apply”, in the third “OK” – and they all do one thing
• The same icon in different sections means different
• The “Close” button closes in one context and deletes in another
• Different behavior of the back button in different sections

Well done

• Design System with Clear Component Agreements
• Dictionary of terms that are used consistently
• The same actions always have the same visual design

** Checklist:**

• The same actions are called the same throughout the product
• The same icons mean the same thing everywhere
• Color coding sequentially (red always = destructive)
• Interaction patterns are the same in similar situations

## Heuristic 5: Prevention of errors

Good design prevents problems before they arise. Better than good error messages.

** Violations:**

• The email field accepts a "test" without warning - the error only appears when sent
• Remove Everything button next to Save Everything without visual separation
• No real-time password validation – error only after sending
• The payment form allows you to enter the expired date of the card without warning

Well done

• Inline Validation as Entered (not After Submission)
• Autoformatting the card number (1234 5678 9012 3456)
• Destructive buttons are visually isolated from safe
• Warning when trying to leave a page with unsaved data

** Checklist:**

• Critical fields are validated in real time, not only when sent
• Destructive actions are visually separated from safe
• Input format prompted in advance (not only in case of error)
• Warning when leaving the form with entered data

## Heuristic 6: Learning is better than remembering

**Principle: * Minimize the cognitive load of the user. Objects, actions and options should be visible. Don’t force you to recall information from one part of the dialogue for use in another.

** Violations:**

• Settings are hidden in three menu levels – the user must remember the way
• The filter parameters are visible only while the filter is open - it is not visible what is applied
• Wizard with 5 steps does not show what was chosen in the previous steps
• Context menus only appear with the right click – it is not obvious that they exist

Well done

• Active filters are visible after the filter panel is closed (cross tags)
• Wizard shows selected parameters in the final step
• Frequently used functions are provided in quick access
• Auto Supplement offers previously entered values

** Checklist:**

• Application filters and settings are visible without opening the panel
• In multi-step flow, previous elections are visible
• Frequently needed features are available without deep navigation
• Tips and examples are visible during filling, not just in error

## Heuristics 7: Flexibility and efficiency

Principle: Hotkeys and fast paths for power users speed up interactions while keeping the interface clear to beginners.

** Violations:**

• No hotkeys for repetitive actions in a professional instrument
• Do not miss the tutorial when re-entering
• There is no quick search, just navigation through the partition tree
• Bulk actions are missing – each element must be handled separately

Well done

• Cmd+K/Ctrl+K for command palette
• Saved filters and search for reuse
• Bulk select and bulk actions to work with multiple elements
• Hot keys for main actions (documented in toults)

** Checklist:**

• Repetitive actions have shortcuts (for professional tools)
• Onboarding can be skipped or folded (repeated users)
• Search for navigation (not just a structured menu)
• Mass operations are possible if the user works with many elements

## Heuristics 8: Aesthetics and Minimalism

Principle: Dialogues should not contain irrelevant or rarely needed information. Each additional element competes with important elements and reduces their visibility.

** Violations:**

• Main screen with 15 metrics, 3 notification blocks and 7 action buttons
• Form with 12 fields when you really need 4
• Each item on the list has 8 action icons visible all the time
• Modal window with 400 words of text

Well done

• Inline-actions appear when hover (does not clutter the interface constantly)
• Progressive Disclosure: Basic fields visible, Expanded under Show More
• Metrics on the dashboard - only the most important, the rest if necessary
• Modals with one action and a minimum of text

** Checklist:**

• There are no items that are not used by most users all the time
• Decorative elements do not compete with functional elements
• Rare functions hidden in secondary actions
• Text in modals and dialogues is minimal and on the case

## Heuristic 9: Assistance in recognition, diagnosis and recovery after errors

Principle: Error messages should be in clear language (not codes), accurately describe the problem and constructively suggest a solution.

** Violations:**

• 403 Error without explaining what happened
• “Something went wrong. Try it later, it doesn’t tell you what to do
• “Incorrect password” doesn’t explain why (capital letter, special character?)
• An error after sending a form does not indicate a specific field

Well done

• “This email has already been registered. [Enter] or [Reset password]
• Error next to a specific field with explanation and example
• When the network fails, “There is no connection.” Check the internet and [try again]
• “Failure to save. Your data is stored locally. [Try again]

** Checklist:**

• Error messages in human language (not codes)
• The mistake explains exactly what went wrong
• Error Offers Specific Action to Recover
• Form errors are tied to specific fields
• No data loss in case of error (this form is saved)

## Heuristic 10: Assistance and documentation

Principle: Even if it is better when the system does not require documentation, sometimes help is needed. It should be easily accessible, focus on the user’s task, and list specific steps.

** Violations:**

• Help center is available only through a link in footer
• Documentation is written in terms of functions, not user tasks
• There are no contextual clues next to complex elements
• Chatbot support cannot answer basic questions

Well done

• in the context of a complex field with an explanation of why it is necessary
• Docs are organized by task ("How to add a member", not "Participant function")
• Documentation search is available from the product (Cmd+K → “How...”)
• Onboarding tooltips for new users

** Checklist:**

• Help is available in context (not just in a separate section)
• Documentation is organized according to user tasks
• Complex fields and functions have contextual clues
• New users can find help without asking for support

## How to perform heuristic analysis: practice

### Rule of three experts

One expert is good. Two independent experts — 1.5 times more finds. Three are almost complete coverage of critical issues.

If you have an opportunity to attract a colleague, do it. Independent assessments are then combined and prioritized.

### Order of passage

1. First pass: no structure like a normal user. Fix what's causing the discomfort.
2. Second passage: each heuristic separately. You only look at one principle, you look for its violations.
3. Endgame: Systematize the findings, assess severity, prioritize.

## AI and Heuristic Analysis: How Claude Finds Violations

### Prompt: full heuristic audit by screenshot

Here is a screenshot of the product.

Target audience: [Description]
The task of the user on this screen: [description]

Conduct a heuristic analysis of 10 Nielsen heuristics.

For each heuristic:
- Are there violations? If yes, specifically what and where
Severity: Critical / Major / Minor / OK
- Recommendation for correction

In the end: Top 3 problems that need to be fixed first.

### Prompt: compare the two options

Here are two options [screen/floo]:
Option A: [screenshot]
Option B: [screenshot]

Evaluate both options by Nielsen heuristics.
Indicate on which heuristics A is better, on which - B.
Offer a hybrid that combines the best of both.

### Prompt: check a specific heuristic

Here is the description of our product: [description] / [screenshots]

Just check the heuristic “[name].”

Find all violations with the indication:
A specific place in the interface
- Why is this a violation (mechanics)
- Specific decision

## How to combine heuristics: patterns of disorders

An experienced eye does not notice individual disturbances, but patterns—how one problem causes another.

### The Invisible State Pattern

Violates several heuristics: status visibility (#1), recognition (#6), sequence (#4).

Symptoms: the user does not understand the state of the system, does not see that its filter is used, does not know whether its action is preserved.

It occurs: in complex filters, in forms with auto-save, in workflow products.

### Pattern "Deadlock Without Exit"

Violates: Control and Freedom (#3), Help After Errors (#9).

Symptoms: The user has fallen into an erroneous state and cannot get out of it without losing data or making an unwanted decision.

Meet: in checkout-floo, onboarding with mandatory steps, in payment flow.

### The Overloaded Screen Pattern

Violates: aesthetics (#8), recognition (#6), error prevention (#5).

Symptoms: There are too many elements of the same visual weight on one screen. The user does not know where to look and what to do first.

It occurs: in dashboards, in settings, in admin panels.

## Heuristics for AI-interfaces: a separate topic

Nielsen’s classic 10 heuristics were written before the AI era. Some of them are directly applicable, some need to be adapted for AI products.

### Heuristic #1 for AI: visibility of process, not just status

For normal software: “loaded” → “ready”. For AI, an “agent thinks” can last minutes. A simple spinner isn't enough.

How to Adapt: Show what AI is doing right now. "Progress log" (analyzing the data) I found 3 relevant sources... The answer is better than a static spinner.

### Heuristic #3 for AI: Controlling the Unpredictable

In conventional software, "cancellation" is understandable. For an AI agent who has already started a multi-step task, what does “back” mean?

How to Adapt: The Stop button is mandatory for the entire period of the agent’s operation. After you stop, show me what happened.

### Heuristics #5 for AI: preventing hallucinations

AI can confidently say the wrong thing. The interface should reduce the risk of mistaking incorrect data for truth.

How to Adapt: Sources for AI Answers, Confidence Indicators, Explicit Separation of “Fact” and “Assumption,” Easy Check Through Links.

### Heuristic #9 for AI: Recovery from the “wrong outcome”

The user got the wrong answer from AI. How do I ask? How do you know? How can I ask you to try something different?

How to adapt: Quick "Try Different" buttons, "Make Shorter/Longer/Formal" buttons. The ability to edit the prompt and regenerate.

## Heuristic analysis in 60 minutes: time management

Heuristics audit is easy to stretch for the whole day. Here's how to keep an hour.

**The rule of two minutes: * If you look for a violation in one heuristic for more than 2 minutes, move on to the next. You come back if you have time. The most serious violations are immediately visible.

## Table template for recording results

| Heuristics | Screen/place | Violation | Severity | Recommendation |
|----------|----------|-------- |-----------|--------------------- |
| #1 Visibility | Payment Form | No confirmation after sending | Critical | Add success-state with next steps |
| #5 Prevent | Remove Project button | No confirmation, next to Save | Major | Confirmation dialogue + visual separation |
| #8 Minimalism | Main dashboard | 18 metrics simultaneously without hierarchy | Major | Prioritize 5-7 keys, the rest in detail |

This table is filled in as you progress - one line per find. At the end, sort by Severity and you get a ready-made list for work.