---
title: "Hick's Law"
source: "/reference/hicks-law"
description: "Decision time tends to increase as the number of plausible choices and the uncertainty between them increase."
---
# Hick's Law

Decision time tends to increase as the number of plausible choices and the uncertainty between them increase.



### Principle

Decision time tends to increase as the number of plausible choices and the uncertainty between them increase.

### Why it matters

Hick's Law is useful for interaction design when users must select among alternatives. The strongest design response is often to improve information architecture, defaults, prioritization, or filtering rather than simply delete options. Familiarity and unequal probability also matter: a common action can remain fast to find inside a large set when placement and labeling are stable.

### Deeper design interpretation

Hick's Law describes the relationship between choice uncertainty and decision time. In interface work, its most useful implication is that simultaneous competition matters. Ten actions distributed across clear categories can be easier than five unrelated actions presented with equal prominence.

The design response should optimize the decision path as a whole. Hiding actions behind additional menus can reduce the visible choice set while increasing navigation, memory, and discovery cost. Familiarity and probability also matter: a common action remains easy to find inside a large set when placement and labeling are stable.

Layr should therefore identify the real decision point before recommending consolidation.

### What the agent should reason about

Count only plausible alternatives competing in the current context. Use analytics or workflow evidence when available to distinguish frequent from rare actions. Evaluate whether categories, defaults, labels, and priority reduce uncertainty.

The agent should avoid “too many buttons” findings unless it can explain how the simultaneous alternatives slow or confuse the current task.

### Common failure patterns

- Every row action is permanently visible with equal weight.
- Rare and frequent commands compete in the same toolbar.
- Long menus have no grouping despite stable categories.
- Labels are so similar that users must read descriptions before choosing.
- Overflow menus are used excessively, forcing repeated extra navigation for common actions.

### Audit questions

- Which choices are truly competing right now?
- Are common actions visually and spatially prioritized?
- Could grouping or labeling reduce uncertainty without hiding capability?
- Does the proposed simplification reduce total task time or only clean the screenshot?

### Example agent finding

> **Medium — Nine row actions compete with equal prominence.** The table exposes nine unlabeled icons even though usage data identifies “Open” and “Assign” as the dominant actions. Keep those two direct, group the remaining low-frequency commands in a labeled overflow menu, and preserve keyboard access.

### Agent directive

> Optimize the decision structure, not the option count in isolation. Identify which choices are genuinely competing at the same moment.

### Apply this when

- Menus, navigation, command surfaces, filter panels, onboarding decisions, pricing, action menus, and branching workflows.

### Observable signals

- Many actions are presented with equal prominence.
- Rare and common actions compete in the same primary surface.
- A menu is long and ungrouped despite stable categories.
- Users must read explanatory text for each option before distinguishing them.
- Several choices lead to nearly identical outcomes.

### Recommended actions

- Prioritize frequent and contextually relevant actions.
- Group alternatives into recognizable categories.
- Move rare actions into secondary menus without making them undiscoverable.
- Use defaults, search, and filters when they reduce uncertainty.
- Merge truly redundant choices.

### Do not over-apply

Do not use Hick's Law to justify hiding everything behind menus. Additional navigation steps add their own cost. Optimize the full task, not one screen.

### Example

**Weak:** A table row exposes nine equal icon buttons, several of which are rarely used and visually ambiguous.

**Stronger:** The two frequent actions remain visible and labeled when space allows; less common actions live in a clearly named overflow menu.

### Evaluation notes

- **Default severity:** Medium; high when decision delay or wrong action affects core workflows.
- **Typical confidence:** High when simultaneous choice sets are observable.
- **Primary evidence:** Action count, frequency data when available, labels, hierarchy, task context.
- **Related rules:** Choice Overload, Selective Attention, Pareto Principle, Fitts's Law

### References

- [Laws of UX — Hick's Law](https://lawsofux.com/hicks-law/)

## Related rules

- [Choice Overload](/__layr/pages/reference/choice-overload.md)
- [Selective Attention](/__layr/pages/reference/selective-attention.md)
- [Pareto Principle](/__layr/pages/reference/pareto-principle.md)
- [Fitts's Law](/__layr/pages/reference/fitts-law.md)

## Agent guidance

Review criteria, the finding contract a report must use, and worked examples.

Established principle; Layr interpretation and agent guidance. Category: Decision, Simplicity & Familiarity.

## Retrieve
- Canonical page: https://layr.design/reference/hicks-law
- Markdown for agents: https://layr.design/__layr/pages/reference/hicks-law.md
- Reference map: https://layr.design/llms.txt
- Route index: https://layr.design/__layr/routes.toon

## Rule object
```yaml
rule:
  id: "hicks-law"
  title: "Hick's Law"
  category: "Decision, Simplicity & Familiarity"
  origin: established
  canonical_url: "https://layr.design/reference/hicks-law"
  principle: "Decision time tends to increase as the number of plausible choices and the uncertainty between them increase."
  directive: "Optimize the decision structure, not the option count in isolation. Identify which choices are genuinely competing at the same moment."
  applies_when:
    - "Menus, navigation, command surfaces, filter panels, onboarding decisions, pricing, action menus, and branching workflows."
  observable_signals:
    - "Many actions are presented with equal prominence."
    - "Rare and common actions compete in the same primary surface."
    - "A menu is long and ungrouped despite stable categories."
    - "Users must read explanatory text for each option before distinguishing them."
    - "Several choices lead to nearly identical outcomes."
  audit_questions:
    - "Which choices are truly competing right now?"
    - "Are common actions visually and spatially prioritized?"
    - "Could grouping or labeling reduce uncertainty without hiding capability?"
    - "Does the proposed simplification reduce total task time or only clean the screenshot?"
  recommended_actions:
    - "Prioritize frequent and contextually relevant actions."
    - "Group alternatives into recognizable categories."
    - "Move rare actions into secondary menus without making them undiscoverable."
    - "Use defaults, search, and filters when they reduce uncertainty."
    - "Merge truly redundant choices."
  avoid_when:
    - "Do not use Hick's Law to justify hiding everything behind menus. Additional navigation steps add their own cost. Optimize the full task, not one screen."
  common_failure_patterns:
    - "Every row action is permanently visible with equal weight."
    - "Rare and frequent commands compete in the same toolbar."
    - "Long menus have no grouping despite stable categories."
    - "Labels are so similar that users must read descriptions before choosing."
    - "Overflow menus are used excessively, forcing repeated extra navigation for common actions."
  evidence_types:
    - "Action count"
    - "frequency data when available"
    - "labels"
    - "hierarchy"
    - "task context"
  default_severity: "Medium; high when decision delay or wrong action affects core workflows."
  typical_confidence: "High when simultaneous choice sets are observable."
  related_rules:
    - { id: "choice-overload", title: "Choice Overload", url: "https://layr.design/reference/choice-overload" }
    - { id: "selective-attention", title: "Selective Attention", url: "https://layr.design/reference/selective-attention" }
    - { id: "pareto-principle", title: "Pareto Principle", url: "https://layr.design/reference/pareto-principle" }
    - { id: "fitts-law", title: "Fitts's Law", url: "https://layr.design/reference/fitts-law" }
```

## What to reason about
Count only plausible alternatives competing in the current context. Use analytics or workflow evidence when available to distinguish frequent from rare actions. Evaluate whether categories, defaults, labels, and priority reduce uncertainty. The agent should avoid “too many buttons” findings unless it can explain how the simultaneous alternatives slow or confuse the current task.

## Routing
Route a review here when the user must choose between alternatives, learn an unfamiliar control, navigate competing actions, or configure a system before reaching value. Inspect the structure of the decision before recommending fewer options.

## Review procedure
For every finding:
1. Identify the exact component, state, route, or interaction.
2. State the observable evidence.
3. Name the principle that applies.
4. Explain the user consequence in the current context.
5. Estimate severity from the consequence, frequency, and reversibility.
6. Recommend the smallest change that addresses the issue while preserving the product's existing design system.
7. Lower confidence when intent, frequency, audience, device, or product constraints must be inferred.
8. Do not produce generic advice such as "improve hierarchy" or "make this clearer" without specifying what is wrong and why.

## Finding contract — emit exactly this shape
```yaml
finding:
  rule_id: string
  location: string
  evidence:
    - observable fact
  impact: string
  severity: low | medium | high | critical
  confidence: low | medium | high
  recommendation:
    change: string
    rationale: string
    preserve:
      - existing design-system behavior
      - valid product constraints
```

## Example finding for this rule
Medium — Nine row actions compete with equal prominence. The table exposes nine unlabeled icons even though usage data identifies “Open” and “Assign” as the dominant actions. Keep those two direct, group the remaining low-frequency commands in a labeled overflow menu, and preserve keyboard access.

## Code reference

The same principle as markup. Compare the structure, not the class names.

```html
<!-- weak -->
<div class="example-ui example-ui-weak">
  <div class="scene-chrome">
    <span class="scene-chrome-app">Projects</span>
    <span class="scene-chrome-view">All projects</span>
  </div>
  <div class="scene-body">
    <div class="scene-panel">
      <span class="scene-panel-title">Atlas redesign</span>
      <div class="scene-row scene-row-muted">
        <span class="scene-meta">Updated today · 8 open tasks</span>
      </div>
      <div class="scene-icon-row">
        <span class="scene-icon-target">✎</span>
        <span class="scene-icon-target">↗</span>
        <span class="scene-icon-target">⧉</span>
        <span class="scene-icon-target">☆</span>
        <span class="scene-icon-target">⌕</span>
        <span class="scene-icon-target">⇧</span>
        <span class="scene-icon-target">⊕</span>
        <span class="scene-icon-target">↓</span>
        <span class="scene-icon-target">⋯</span>
      </div>
      <span class="scene-note">9 unlabelled targets · equal weight · rare beside frequent</span>
    </div>
  </div>
</div>
```

```html
<!-- stronger -->
<div class="example-ui example-ui-strong">
  <div class="scene-chrome">
    <span class="scene-chrome-app">Projects</span>
    <span class="scene-chrome-view">All projects</span>
  </div>
  <div class="scene-body">
    <div class="scene-panel">
      <span class="scene-panel-title">Atlas redesign</span>
      <div class="scene-row scene-row-muted">
        <span class="scene-meta">Updated today · 8 open tasks</span>
      </div>
      <div class="scene-row">
        <span class="scene-action">Open</span>
        <span class="scene-action">Share</span>
        <span class="scene-action scene-action-quiet">More ⌄</span>
      </div>
      <div class="scene-menu">
        <span class="scene-menu-group">Organise</span>
        <span class="scene-menu-item">Duplicate</span>
        <span class="scene-menu-item">Move to…</span>
        <span class="scene-menu-group">Lifecycle</span>
        <span class="scene-menu-item">Archive</span>
      </div>
      <span class="scene-note">2 frequent actions visible · the rest named and grouped</span>
    </div>
  </div>
</div>
```

```css
/* declarations these studies depend on */
.example-ui { display: grid; grid-template-rows: auto minmax(0, 1fr); min-width: 0; min-height: 17rem; overflow: hidden; border: var(--border-thin) solid var(--color-border-strong); background: var(--color-background); color: var(--color-text); font-size: var(--text-xs); line-height: var(--leading-snug); }
.example-ui .scene-chrome { display: flex; flex-wrap: wrap; align-items: baseline; gap: var(--space-1) var(--space-2); padding: var(--space-2) var(--space-3); border-bottom: var(--border-thin) solid var(--color-border-strong); background: var(--color-surface); }
.example-ui .scene-chrome-app { font-size: var(--text-2xs); font-weight: 600; letter-spacing: var(--tracking-label); text-transform: uppercase; }
.example-ui .scene-chrome-view { color: var(--color-text-tertiary); font-size: var(--text-2xs); }
.example-ui .scene-body { display: grid; align-content: start; gap: var(--space-3); min-width: 0; padding: var(--space-3); }
.example-ui .scene-body:has(> .scene-panel:only-child) { align-content: stretch; }
.example-ui .scene-panel { display: grid; align-content: start; justify-items: start; gap: var(--space-2); min-width: 0; padding: var(--space-3); border: var(--border-thin) solid var(--color-border-strong); background: var(--color-surface-raised); }
.example-ui .scene-panel-title { font-size: var(--text-sm); font-weight: 600; letter-spacing: var(--tracking-heading); }
.example-ui .scene-row { display: flex; flex-wrap: wrap; justify-content: space-between; align-items: center; gap: var(--space-1) var(--space-2); width: 100%; min-width: 0; padding-block: var(--space-1); }
.example-ui .scene-panel > .scene-row + .scene-row { border-top: var(--border-thin) solid var(--color-border-subtle); }
.example-ui .scene-row-muted { color: var(--color-text-tertiary); }
.example-ui .scene-meta { color: var(--color-text-tertiary); font-size: var(--text-2xs); }
.example-ui .scene-note { width: 100%; padding-top: var(--space-2); border-top: var(--border-thin) solid var(--color-border-subtle); color: var(--color-text-tertiary); font-family: var(--font-mono); font-size: var(--text-2xs); line-height: var(--leading-snug); }
.example-ui .scene-action { display: inline-flex; align-items: center; justify-content: center; min-height: var(--space-8); padding-inline: var(--space-3); border: var(--border-thin) solid var(--color-border-strong); border-radius: var(--radius-xs); background: var(--color-surface-raised); color: var(--color-text); font-size: var(--text-xs); font-weight: 550; white-space: nowrap; }
.example-ui .scene-action-quiet { border-color: transparent; background: none; color: var(--color-text-secondary); padding-inline: var(--space-1); text-decoration: underline; text-underline-offset: 3px; }
.example-ui .scene-icon-row { display: flex; flex-wrap: wrap; gap: var(--space-1); width: 100%; }
.example-ui .scene-icon-target { display: inline-grid; place-items: center; width: var(--space-6); height: var(--space-6); border: var(--border-thin) solid var(--color-border-strong); font-size: var(--text-2xs); }
.example-ui .scene-menu { display: grid; justify-items: stretch; gap: 0; width: 100%; padding: var(--space-1); border: var(--border-thin) solid var(--color-border-strong); border-radius: var(--radius-sm); background: var(--color-surface-raised); box-shadow: var(--shadow-floating); }
.example-ui .scene-menu-group { padding: var(--space-2) var(--space-2) var(--space-1); color: var(--color-text-tertiary); font-size: var(--text-2xs); font-weight: 600; letter-spacing: var(--tracking-label); text-transform: uppercase; }
.example-ui .scene-menu-item { padding: var(--space-1) var(--space-2); }
.example-ui { min-height: 15rem; }

/* resolved values */
:root {
  --border-thin: 1px;
  --font-mono: "Geist Mono", "SFMono-Regular", Consolas, "Liberation Mono", monospace;
  --leading-snug: 1.35;
  --radius-sm: 4px;
  --radius-xs: 2px;
  --shadow-floating: 0 1px 2px rgb(17 17 15 / 5%), 0 8px 24px rgb(17 17 15 / 8%);
  --space-1: 0.25rem;
  --space-2: 0.5rem;
  --space-3: 0.75rem;
  --space-6: 1.5rem;
  --space-8: 2rem;
  --text-2xs: 0.6875rem;
  --text-sm: 0.875rem;
  --text-xs: 0.75rem;
  --tracking-heading: -0.025em;
  --tracking-label: 0.06em;
}
```

## Weak vs stronger
- Weak: A table row exposes nine equal icon buttons, several of which are rarely used and visually ambiguous.
- Stronger: The two frequent actions remain visible and labeled when space allows; less common actions live in a clearly named overflow menu.

## Reporting rules
- Report only what the interface shows as observable evidence; phrase psychological or motivational effects as possible consequences.
- Returning no finding is a valid result when evidence is insufficient.
