The Human Mind. Design for the brain people actually have.

Every interface is read by a perceptual system that groups and guesses, steered by an attention that is narrow, held in a memory that holds about four things, and acted on by a hand that obeys physics. This guide teaches the psychology under the "laws of UX": what each one says, where the evidence is strong or shaky, and exactly how to use it in the software you build alone.

Reading timeAbout 4 hours, in 6 sittings (one per part)
Practice time2 weeks, about 30 minutes a day
Before thisFoundations
TeachersWertheimer, Treisman, Miller, Cowan, Hick, Fitts, Kahneman, Simon, Raskin, Norman, Csikszentmihalyi, Fogg, Deci & Ryan

By the end you will be able to

  • Explain how perception, attention and memory shape what people see and miss on a screen (understand)
  • Name the Gestalt principle, scanning pattern or memory limit at work in any layout you look at (analyze)
  • Judge which "laws of UX" have strong evidence, which are useful rules of thumb, and which are overstated (evaluate)
  • Use Fitts's, Hick's and the response-time limits to size targets, shape menus and budget latency (apply)
  • Design defaults, progress, feedback and endings that respect people's motivation instead of exploiting it (create)
  • Run a cognitive audit of your own product with the checklist in chapter 21 (create)

Warm-up: what do you already believe?

Before the theory, test your intuitions. Psychology is the one design subject where everyone already has strong opinions, and many popular ones are half right. Answer quickly; you will meet each of these again later, and noticing where you changed your mind is how the learning sticks.

Diagnostic 1 of 3

A colleague says "Miller proved people can only handle seven menu items, so cap the nav at seven." What is the best response?

Diagnostic 2 of 3

Your "Save" button is 24×24 px in the top-right of a 1440 px wide window, and people use it constantly. Which change makes it fastest to hit?

Diagnostic 3 of 3

A study shows that offering 24 jams instead of 6 made shoppers ten times less likely to buy. What should you conclude for your app's pricing page?

How to study this guide

Read one part per sitting. Do every demo with your hands, not just your eyes: the point of the labs is that you feel the effect in your own reaction times. Keep your own product open in another window. Each exercise is designed to take under an hour and produce something you keep: an annotated screenshot, a rewritten flow, a latency budget. By the end you will have a cognitive audit of your product, which is worth more than any summary.

Part one

Perception: what the eye hands the brain

Before anyone reads a word of your interface, their visual system has already grouped it, sorted figure from background, and flagged what stands out. This happens in a fraction of a second, without effort and without consent. Design that works with these automatic processes feels obvious. Design that fights them feels confusing even when every label is correct.

1

Seeing is guessing

Taught by Hermann von Helmholtz, with Richard Gregory and Colin Ware

The eye does not photograph your screen. It samples a tiny sharp spot, fills the rest with prediction, and builds meaning from edges and contrast, so your layout is understood mostly by what the brain expects.

Hold your thumb at arm's length. The nail covers roughly the part of the world you see in sharp detail: the fovea, about 1 to 2 degrees of visual angle. On a laptop at normal distance, that is a patch only a few words wide. Everything else is peripheral vision: blurry, poor at color, but very good at motion and at big shapes. Your eyes jump three or four times a second (saccades) and the brain stitches those snapshots into the illusion of a stable, sharp page.

Helmholtz called perception "unconscious inference" in the 19th century, and the psychologist Richard Gregory built on it: what you see is the brain's best hypothesis about what is out there, given the sparse input and everything it has seen before. That is why people "see" a button that is just a colored rectangle, why a hairline under text reads as a link, and why users miss a warning written in the place they never look.

Fovea: 1 to 2 degrees a few words in focus Periphery blurry, weak color, great at motion and large shapes 3 to 4 saccades a second stitch these snapshots into one "sharp" page
The sharp window is tiny. Anything you need read must land where the eye goes. Anything you need noticed from the corner of the eye must use what the periphery is good at: size, contrast and (sparingly) motion.

Edges and contrast come first

Early vision is built to find edges: places where brightness changes. Your retina and visual cortex respond to differences much more than to absolute values. That is why the same gray looks lighter on a dark background (simultaneous contrast), and why a border and a change of background tone are equally good at saying "this is a separate thing". It is also why low-contrast interfaces fail: when the luminance difference between text and background is small, the edge-detecting machinery has less signal, reading slows, and the page feels foggy. Contrast ratios and their exact thresholds belong to Accessible & Inclusive and Visual Design; here the point is the mechanism: luminance contrast is the raw material of every edge, shape and group.

same gray same gray
Simultaneous contrast. The two inner squares are the same token. The one on the dark ground looks lighter. Your visual system reports differences, not values, which is why a color that works in light mode can fail in dark mode.

Expectation is part of the input

Because perception is inference, prior experience changes what people see. A blue underlined phrase is a link before it is read. A gray rounded rectangle at the bottom of a phone screen is a home indicator, not a control. An "X" in the top-right corner closes things. When you break these expectations, you are not just being original: you are asking the brain to override a confident prediction, which costs time and causes errors. This is the perceptual root of Jakob's law (chapter 18).

Don't
Weekly digest You have 12 new highlights. Read them here or change settings. Open Later
No edges, no prediction. "here" and "Open" look exactly like text, so the brain predicts "nothing to press". People hunt by hovering.
Do
Weekly digest You have 12 new highlights. Read them or change settings Open Later
Edges announce affordances. A filled shape and an underline match what the brain has seen ten thousand times. No hovering needed.

Do

  • Put what must be read where the eye already goes (near the last thing they acted on).
  • Use luminance contrast, not only hue, to make edges and groups.
  • Lean on learned visual conventions for controls: filled buttons, underlined links, chevrons for "more".
  • Check every screen in both light and dark mode, because contrast is relative.

Don't

  • Assume people see the whole screen because it fits in the window.
  • Rely on subtle 3–5% tone differences to separate areas.
  • Style actions as plain text "for minimalism" when they are primary.
  • Put important status changes in the far periphery and expect them to be read.

In the wild

  • iOS 7Apple, 2013
    The flat redesign removed button borders and made many buttons plain tinted text. Apple later added an accessibility setting ("Button Shapes") to put back visible shapes. When you remove edges, some people lose the signal that something is pressable.
  • iA WriterInformation Architects, 2010–
    The writing view is almost only text, but the cursor is a strong, saturated blue bar. The one thing you must find instantly has the most contrast. Minimal does not mean low contrast everywhere; spend contrast on what matters.
  • Google Search resultsGoogle
    Blue result titles have looked like links for decades. Each time a variation is tested, the conventional pattern carries enormous expectation. A strong convention is free comprehension you inherit.
For the solo creator

You know your interface too well to see it fresh: your brain predicts it perfectly. Two cheap tricks restore a stranger's eyes. Blur a screenshot (a 6–8 px Gaussian blur) and ask "what are the three things I notice, and are they the right three?". Then switch to grayscale and check that every group and button still has an edge. Both take two minutes and catch most perceptual problems before anyone else sees them.

Common mistakes

Designing at arm's length, reviewing at nose length

You inspect your mockups zoomed in, so every detail is foveal and clear.

Review at real size and distance, and with the blur test, so you see what peripheral vision sees.

Hue-only distinctions

Two colors look different to you, but have nearly the same lightness, so their edge is weak (and invisible to many color-blind users).

Check groups and states in grayscale. If they vanish, add a lightness difference, a border or an icon.

Breaking a convention to look fresh

Originality feels like design. But the brain predicts the old pattern and the new one has to fight it.

Be original in the places people do not need to predict (tone, typography, details), conventional in controls.

Check yourself

Users of your note app keep missing the small "Synced" status that changes to "Offline" in the bottom-left corner while they type in the center. What is the best explanation and fix?

Exercise 1.1 30 minutes · on your own product

The blur and grayscale pass

  1. Take full-size screenshots of your three most-used screens.
  2. Blur each by about 8 px. Write down the first three things you notice on each, in order.
  3. Write next to them the three things a new user should notice, in order.
  4. Convert the originals to grayscale. Circle every control or group that loses its edge.
  5. Fix the worst mismatch in code and repeat the blur test.
You're done when: you have three blurred screenshots annotated "noticed vs intended", and one before/after pair showing a fix.
BeginnerCompetentStrong
Screens blurred and noticed items listed.Mismatches found and one fixed with contrast or size.Fix verified by a second blur, and a rule written down ("primary action is always the highest-contrast element").
2

Gestalt I: how things become groups

Taught by Max Wertheimer, with Kurt Koffka, Wolfgang Köhler and Stephen Palmer

People do not see twenty elements; they see four groups. Nearness, likeness, shared containers and connecting lines decide which groups, and your layout means whatever those groups say.

The Gestalt psychologists in Germany in the 1910s and 1920s showed that perception organizes before it identifies. Wertheimer's 1923 paper laid out "laws of organization": rules by which the visual system decides what belongs together. A century later these are among the most reliable findings in all of design psychology, because you can demonstrate them on anyone in seconds. Stephen Palmer added two more in the 1990s, common region and uniform connectedness, that turn out to be the strongest of all for interfaces.

Why it matters: grouping is how people answer "what is related to what?" without reading. If a label is closer to the wrong field, people attach it to the wrong field. If two buttons look the same, people assume they do the same kind of thing. The structure your code has (which div contains what) is invisible. Only the perceived grouping exists for the user.

Proximity Same dots; the gap makes two columns. UI: label sits closer to its own field. Similarity Even spacing, but color makes columns. UI: all links look alike, all tags look alike. Common region A shared background beats equal spacing. UI: cards, grouped settings sections. Uniform connectedness A line binds two things more than spacing does. UI: steppers, threads, linked fields.
Four grouping forces, roughly weakest to strongest. When they conflict, explicit connection and shared regions usually beat similarity, and similarity can beat proximity. Use the weakest one that does the job, so the screen stays quiet.

Proximity: spacing is meaning

Proximity is the cheapest grouping tool you have, because it uses empty space instead of ink. The rule of thumb for forms: the gap between a label and its own field should be clearly smaller than the gap between that field and the next label. A 4 px label gap against a 20–24 px gap between fields (roughly 1:5) reads unambiguously. Equal gaps (say 12 px everywhere) make every label float between two fields.

Proximity in a form
First name
Last name
Email
Phone
Equal gaps: every label is the same distance from the field above and below. Your eye has to work out which one it names, and the four fields read as one undifferentiated stack.

Similarity: same look, same job

Things that share color, shape, size or type style are seen as belonging together, and, crucially, as doing the same kind of thing. That is a promise. If every tag is a gray pill and one gray pill is actually a button that deletes, you have broken the promise. Similarity is also why consistency matters so much: when two buttons that do different things look identical, people assume they are equivalent.

Common region and connectedness: the strong glue

Palmer showed in 1992 that elements inside a shared boundary group together even when proximity says otherwise, and with Irvin Rock (1994) that elements joined by a line group more strongly still. In interfaces these are the card, the panel, the inset grouped list, the line between steps. They are powerful, so they are also noisy: a screen where everything sits in a bordered box has many regions and therefore no hierarchy. Calm interfaces such as iA Writer, Things and Apple's Settings mostly use proximity and a few large regions, not a box around every element.

Don't
Dark mode Font size Sync account Sign out 4 boxes, 0 groups
Boxes everywhere cancel out. Each row has its own region, so nothing is grouped and "Sign out" looks as harmless as "Font size".
Do
APPEARANCE Dark modeFont size ACCOUNT Sync accountSign out
Two regions, two meanings. Proximity inside, common region around, a gap between. The destructive action is set apart by color (similarity used deliberately to break the group).

Do

  • Make inner spacing clearly smaller than outer spacing (a ratio of at least 1:2, often 1:4).
  • Give items that do the same thing the same appearance, everywhere.
  • Use a few large regions (sidebar, content, inspector) rather than many small boxes.
  • Use connecting lines only where a sequence or relationship truly exists.

Don't

  • Use the same 16 px gap between everything "for consistency".
  • Style a destructive or different action exactly like its harmless neighbours.
  • Nest cards inside cards inside panels.
  • Let a label sit equally between two fields.

In the wild

  • iOS SettingsApple, inset grouped lists
    Related settings sit in rounded regions separated by generous gaps and small uppercase headers. Common region plus proximity organizes hundreds of settings without a single border line around a row.
  • Things 3Cultured Code, 2017
    Headings inside a project group to-dos almost entirely by whitespace and a thin heading rule. Proximity alone can carry structure in a calm product.
  • Stripe CheckoutStripe
    Card number, expiry and CVC are joined into one bordered block with internal dividers. Common region tells you "these three fields are one thing: your card".

Common mistakes

The uniform spacing token

A design system with one spacing value feels tidy, so everything gets 16 px.

Use a scale (4, 8, 16, 24, 32, 48) and assign by relationship: tight within a group, loose between groups.

Borders as a substitute for structure

Drawing a box is easier than deciding what belongs together.

Decide the groups first, express them with space, and add a region only when space is not enough.

Accidental similarity

You reused a component (a pill, a chip) for something that behaves differently.

Different behavior gets a visibly different form. Same behavior gets the same form.

Check yourself

In your invoice app, users keep editing the "Tax" field when they mean to edit "Discount". Both fields are in a single row with 12 px gaps, and each label sits 12 px above its field and 12 px below the row before. What will fix it with the least visual noise?

Exercise 2.1 40 minutes · on your own product

Draw the groups people see

  1. Pick your densest screen. Print it or put it in a drawing app.
  2. Without thinking about the code, draw a loose outline around every group your eye sees. Use a different color for groups formed by space, by region, by similarity and by lines.
  3. Now list the groups you intended (from your data model or the user's task).
  4. Mark every place where a perceived group does not match an intended one.
  5. Fix one mismatch using spacing alone. Only if that fails, add a region.
You're done when: you have the annotated screen, a list of mismatches and a before/after of one fix that added no new borders.
BeginnerCompetentStrong
Groups outlined.Mismatches named by principle ("labels group by proximity with the wrong field").Fixed with spacing only, and spacing scale written into your CSS tokens.
3

Gestalt II: shape, depth and motion

Taught by Max Wertheimer, with Edgar Rubin and Kurt Koffka

The visual system completes broken shapes, follows smooth paths, separates a figure from its ground, binds things that move together, and always prefers the simplest reading. Each of these is a lever for making an interface feel obvious.

Chapter 2 was about which things belong together. This chapter is about which shapes, layers and movements the brain constructs. These principles explain why a half-visible card invites a swipe, why a modal over a dimmed page feels like it is "on top", and why a selected batch of files feels like one object when you drag it.

Continuity We see two smooth curves crossing, not four bent pieces meeting. UI: aligned edges, sliders Closure A square, though the outline has gaps. UI: icons, peeking cards Figure-ground Modal Smaller, brighter, enclosed areas read as figure; the rest recedes. UI: dimmed backdrops Common fate The three that move together become a group. UI: multi-select drag Prägnanz A circle and a square, not one odd shape. Simplest reading wins. UI: clear, simple forms
Five ways the brain builds form. None of these need the user to think. That is the point: an interface built on them explains itself before it is read.

Continuity and alignment

The eye prefers to follow smooth, continuous lines and edges. In layout, that makes alignment a grouping force: elements whose left edges sit on one invisible line are read as a column, and one element that is 3 px off breaks the line and looks like a mistake. It also explains horizontal scrolling rows: when cards continue off the edge of the screen, the eye follows the row and infers there is more.

Closure: what the brain fills in

Given a partial outline, people perceive the complete shape. This is why icons can be drawn with very few strokes, and why the "peek" works: in a horizontal carousel, a card cut off at the right edge is completed by the mind, which also tells it "there is more here, scroll". When every card fits exactly, nothing hints at more, and people may never swipe.

Don't
Collections Looks complete. 9 more are hidden.
Nothing to complete. The row ends at the edge, so the brain closes it: "that is all there is".
Do
Collections The cut card says "swipe for more".
Closure as a signifier. Sizing cards so the last one is cut by roughly a third makes the continuation visible without an arrow.

Figure-ground: what is on top

Edgar Rubin's 1915 vase/faces figure shows that the brain must decide which region is the object and which is the background, and it cannot see both at once. Smaller, enclosed, higher-contrast and lower regions tend to become figure. Interfaces use this constantly: a modal on a dimmed page, a popover with a shadow, a selected row with a filled background. If the ground is not pushed back (the page behind a dialog at full brightness), people are unsure which layer they are in, and click the wrong one.

Common fate: things that move together

Elements that move in the same direction at the same time are grouped, overriding even color and proximity. This is why animation can explain structure: when you collapse a section and its children slide up together, the user learns that they belonged to it. When you drag five selected files and they gather into a stack under the cursor, they become one object. Motion design builds on this in Motion & Feel.

Prägnanz: the simplest reading wins

"Prägnanz" (roughly "conciseness") is the Gestalt umbrella law: the brain resolves ambiguity in favor of the simplest, most regular interpretation. Designers use it two ways. First, give people simple forms so they do not have to resolve anything. Second, when your layout has an accidental simple reading (two unrelated panels that happen to align into a single block), people will see that reading, not yours.

Myth

"Gestalt principles are just design theory." They are among the best-replicated phenomena in perception research, studied with reaction times and neural recordings for a century. What is less exact is their relative strength in any given layout: that depends on how big the spacing, color or size differences are, so you still have to look.

Do

  • Align to a small number of strong edges so continuity does the grouping.
  • Let one card peek past the edge in any horizontal scroller.
  • Dim or blur the background behind a modal so figure and ground are unambiguous.
  • Animate grouped items together when they change state together.

Don't

  • Leave elements 2–4 px off the alignment line.
  • Fit carousel items exactly to the screen width.
  • Open dialogs over a full-brightness page that still looks interactive.
  • Animate unrelated elements on the same timing; people will assume they are related.

In the wild

  • App Store "Today" and shelf rowsApple
    Horizontal shelves size items so the next one is visibly cut at the edge. Closure tells you there is more without arrows or "see all".
  • macOS FinderApple
    Dragging several selected files shows them gathered under the pointer with a count badge. Common fate turns many items into one draggable object.
  • iOS sheetsApple, iOS 13 and later
    A sheet slides up while the page behind scales back slightly and darkens. Figure-ground made physical: you know which layer you are in.

Common mistakes

Near-miss alignment

Elements are positioned by hand or by different components with different paddings.

Use one layout grid and shared padding tokens; check with a vertical guide line across the screen.

Weak modal ground

A transparent overlay at 10% looks subtle in a mockup.

Make the backdrop clearly darker (or blurred) and block clicks on it; the ground must look inactive.

Decorative motion that groups by accident

A staggered entrance animation moves the sidebar and the content at the same time.

Only animate together what belongs together, and keep entrance motion short or absent.

Check yourself

Your reading app shows "Continue reading" as a horizontal row of book covers. Analytics show almost nobody scrolls the row. Covers are 100 px wide and three fit exactly on a 360 px screen with gutters. What is the most likely fix?

Exercise 3.1 25 minutes · on an app you use daily

Gestalt spotting walk

  1. Open three apps you use every day (for example your mail, notes and a reader).
  2. Find one clear instance each of continuity, closure, figure-ground, common fate and Prägnanz. Screenshot them.
  3. Find one place where a principle produces a wrong reading (an accidental group, an ambiguous layer).
  4. Write one sentence for each: principle, what it makes you perceive, whether that matches the designer's intent.
You're done when: you have a page of six annotated screenshots, one of which is a failure with a proposed fix.
BeginnerCompetentStrong
Five principles found.Each explained by mechanism, and one failure found.Failure fixed in a quick mock, and you can say which principle would be the lightest fix.
4

Pop-out: preattentive attributes and visual search

Taught by Anne Treisman, with Christopher Healey, Colin Ware and Jeremy Wolfe

A few visual features (color, size, orientation, motion, and some others) are detected in parallel across the whole screen in a fraction of a second. Anything that differs by one of them pops out. Anything that differs only by a combination must be searched for, one item at a time.

In 1980 Anne Treisman and Garry Gelade published feature integration theory. Their experiments showed two kinds of search. When the target differs from distractors by a single feature (a red item among blue ones), search time stays roughly flat no matter how many distractors there are: the target "pops out". When it differs only by a conjunction (a red circle among red squares and blue circles), search time grows with the number of items, as if attention must visit each one. The features that pop out are called preattentive: they are processed before focused attention, in roughly 200–250 ms.

For design, this is a budget. Pop-out is the most powerful tool you have for guiding the eye, and it only works when one thing differs. Make five things pop and none of them do. Try it yourself below.

Time to find target Number of items on screen 41632 Feature: flat ("pop-out") Conjunction: rises serial, item by item
Schematic of the classic result. Shape of the curves after Treisman and Gelade (1980); exact times vary by person and display. Later work by Jeremy Wolfe showed search is more of a continuum ("guided search"), but the design lesson holds: single-feature differences guide the eye; combinations make people hunt.

The preattentive toolkit

Researchers have listed many preattentive features. The ones you will use in interfaces are:

FeatureStrength in UIUse it forWatch out
Color (hue)Very strong when only one or two items differUnread dots, errors, the one primary buttonFails for color-blind users unless lightness also differs
Lightness / contrastVery strongSelected state, primary text vs secondaryLow-contrast "subtle" states vanish
SizeStrongHeadlines, key numbersSmall size differences (14 vs 15 px) do not pop
OrientationModerateChevrons, rotated disclosure trianglesRarely useful for large areas
Motion / flickerStrongest of all, especially in the peripheryTruly urgent changesImpossible to ignore, so it steals focus; respect reduced motion
Enclosure, added marksStrongBadges, focus rings, a dotMany badges cancel each other
Don't
Everything pops, so nothing does. The one urgent message (row 4) differs only by a conjunction of colors and is lost.
Do
One difference, instant find. Quiet rows make a single marker (color plus weight plus a dot) pop out preattentively.
Key idea

Salience is relative. A color is loud only on a quiet background. Spend your pop-out budget on one or two things per screen.

Do

  • Keep the baseline quiet so one difference can pop.
  • Make a pop-out cue redundant: color plus lightness, or color plus a shape or icon.
  • Sort or group lists so people can search a subset instead of everything.
  • Reserve motion for things that truly need to interrupt.

Don't

  • Color-code six categories and expect any of them to be findable at a glance.
  • Signal the important item by a combination of two subtle features.
  • Use animated badges for routine counts.
  • Make "new", "beta", "pro" and "sale" badges compete on one screen.

In the wild

  • Apple Mail / iOS MailApple
    Unread messages get a single blue dot and bolder sender name in an otherwise quiet list. One feature, redundantly coded, scanned at a glance.
  • Xcode, VS Code guttersApple, Microsoft
    Errors appear as red marks in the scrollbar and gutter, so you can find them in a 3,000-line file by pop-out rather than reading. Preattentive marks turn search into a glance.
  • LinearLinear, 2019–
    The issue list is mostly grayscale; color is kept for small status and priority icons. A quiet baseline makes small colored marks readable.

Common mistakes

Rainbow categories

Color feels like organization, so every project, tag and status gets its own hue.

Use color for one dimension at most, and for at most 5–7 categories; use labels and position for the rest.

Everything bold

Each feature request asks for emphasis, and emphasis accumulates.

Per screen, decide the one thing that must pop. Demote everything else, and review emphasis whenever you add something.

Color-only status

Red and green look clearly different to you.

About 1 in 12 men has some color vision deficiency. Pair color with lightness, an icon or text (see Accessible & Inclusive).

Check yourself

Your habit tracker marks overdue habits with a red label, completed ones with a green label, scheduled ones with a blue label and paused ones with a gray label. Users say they "can't find what is overdue". What do you change?

Exercise 4.1 30 minutes · on your own product

The salience budget

  1. On your main screen, list every element that uses a saturated color, bold weight, badge, icon-in-color or motion.
  2. Rank them by how important it is that the user sees them within one second.
  3. Keep pop-out for the top one or two. Demote the rest to the quiet baseline.
  4. Time a friend (or yourself after a day away) finding the top item before and after.
You're done when: you have a ranked salience list, a demoted version of the screen, and before/after find times.
BeginnerCompetentStrong
Salient elements listed.Demoted to one or two pop-out items.Find time measured, and a written "salience rule" added to your design notes.
5

What people miss: change and inattentional blindness

Taught by Daniel Simons, with Christopher Chabris, Ronald Rensink, Arien Mack and Irvin Rock

People do not notice changes they are not attending to, even large ones, and they do not see unexpected things while focused on a task. An update that happens silently on screen is, for most users, an update that never happened.

In 1997 Ronald Rensink, Kevin O'Regan and James Clark showed people two versions of a photo alternating with a brief blank screen in between. Large changes (a whole engine missing from an airplane) took many seconds to spot. Without the blank, the change popped out instantly, because the motion signal of the change drew attention. The blank (like a page reload, a blink or a scroll) erases that signal. This is change blindness.

In 1999 Daniel Simons and Christopher Chabris asked people to count basketball passes in a video. About half failed to notice a person in a gorilla suit walking through the scene. This is inattentional blindness: when attention is committed to a task, unexpected things are not seen at all, even in the fovea. Mack and Rock's 1998 book named the effect after years of lab work.

Both effects are robust and replicate well. They demolish the designer's assumption that "it is on the screen, so they saw it".

Lab: spot the change
Your order Field notebook, A5₹ 640 Fountain pen, fine₹ 1,250 Ink, blue-black₹ 390 ShippingFree Total₹ 2,280 Pay now
Press Play. Two versions alternate with a blank between. Find what changes.
With the blank, most people need several cycles. Switch to "No blank" and the change jumps out at once, because the change itself becomes a motion signal. If your system asks for reduced motion, Play is replaced by manual stepping; the flash rate stays under 3 per second either way.

Where change blindness bites in software

  • Full reloads after an action. The page blanks, re-renders, and the one line that changed ("Shipping: ₹ 120") is invisible.
  • Silent recalculation. A total updates when a coupon fails, in a corner the user is not looking at.
  • Validation errors far from the field, shown at the top of a long form after submit, while attention is at the bottom on the button.
  • Toasts and snackbars that appear in a corner while the user is focused on the content, and vanish in 4 seconds.
  • Auto-saved settings with no confirmation near the control.
Hidden change Total ₹ 2,280 reload Total ₹ 2,400 No motion signal.Change goes unseen. Visible change Total ₹ 2,280 Total ₹ 2,400+ ₹ 120 shipping Update in place, briefhighlight, say what changed.
Make changes visible where they happen. Update in place without a blank, add a short highlight (about 1 to 2 seconds), and state the reason next to the number.

Do

  • Update content in place rather than reloading the page.
  • Put feedback next to the control or the value that changed.
  • Use a brief highlight or transition to mark a change, then let it settle.
  • State important changes in words ("Shipping added: ₹ 120").

Don't

  • Rely on users noticing a recalculated number.
  • Show errors only in a summary at the top of the page.
  • Use 3-second toasts for things people must read.
  • Assume a design review where you knew what changed tells you anything about noticing.

In the wild

  • Google DocsGoogle
    Collaborators' cursors and selections appear in color with name labels right where they are editing. Changes made by others are made visible at the place of change.
  • Single-page web appsa pattern
    Inline validation that appears next to a field as you leave it replaced many full-page "submit and reload" forms. No reload, no blank, no change blindness.
  • Figma multiplayerFigma
    You see other people's cursors moving live, so changes to the canvas have a visible cause. Motion of the cause makes the change noticeable and explainable.
For the solo creator

Because you build the feature, you always know what changed, so you can never test this on yourself. Use a "fresh eyes" trick: record your screen while doing a task, wait a day, then watch it at normal speed and note every change you fail to notice. Or ask one friend to do the task and say aloud what they think just happened after each click.

Common mistakes

"It's on the screen"

Designers review with full knowledge of what changes.

Assume nothing is seen unless it is at the locus of attention or announced. Test with someone who does not know.

Toast for consequential news

Toasts are easy to add and feel non-intrusive.

Use toasts only for confirmations that can be missed safely ("Copied"). Anything consequential belongs inline and persistent.

Check yourself

In your budgeting app, applying a filter reloads the whole table, and a summary line at the bottom silently switches from "All accounts" to "2 accounts hidden". Users get confused totals. Best fix?

Exercise 5.1 45 minutes · on your own product

The silent-change hunt

  1. List every action in your product that changes something other than what was directly clicked (totals, sync state, sort order, other panes).
  2. For each, write where the change appears and where the user's eyes are at that moment.
  3. Mark each "seen" or "likely missed".
  4. Redesign the worst one so the change is announced at the locus of attention.
You're done when: you have a table of side-effects with seen/missed ratings and one redesigned interaction in code.
BeginnerCompetentStrong
Side-effects listed.Rated by locus of attention and one fixed.Fix tested on another person who noticed the change unprompted.
Part one recap: connect the ideas

A dashboard has twelve colored KPI tiles in equal boxes. When a value crosses a threshold, its tile turns red after the page auto-refreshes. Which combination of ideas from this part explains why people miss it?

Part two

Attention: the narrow beam

Perception gathers everything; attention picks almost nothing. It is a single, narrow, easily captured beam, and every interface competes for it with the user's own goals, the operating system, other apps and the room they are sitting in. This part covers how attention is limited, how people actually scan screens, and what interruptions and flow do to the work people come to your product to do.

6

One beam: limited attention and the locus of attention

Taught by Jef Raskin, with Daniel Kahneman, Jan Panero Benway and Herbert Simon

People can consciously attend to one thing at a time. Your interface either supports that one thing or competes with it, and anything that looks like an ad, a promotion or a nag is learned to be invisible.

Jef Raskin, who started the Macintosh project at Apple, put it plainly in The Humane Interface (2000): we have one "locus of attention", the single object or idea we are consciously engaged with. You can walk and talk, but you cannot attend to two conversations. Skills that are fully automatic (typing for a fast typist) do not need the locus, which is why they can run alongside thought. Everything else queues.

Herbert Simon made the economic version of the point in 1971: "a wealth of information creates a poverty of attention". Each element you add to a screen draws a little from the same fixed budget. Kahneman's Attention and Effort (1973) treated attention as a limited capacity that is spent by effortful tasks; when one task is demanding (composing a hard email), people miss things that would be obvious when relaxed.

On screen sidebar upgrade banner the task badge (3) toast chat bubble selection locus of attention capacity: one
Everything else queues or is filtered. Every element on the left costs a little to filter out, even if it never wins. That cost is what makes cluttered tools tiring.

Banner blindness: attention learns to ignore

In 1998, Jan Panero Benway and David Lane found that people searching a site failed to find information placed in a large, colorful banner at the top, even though it was exactly what they were looking for. Later eye-tracking by Nielsen Norman Group repeatedly showed users skipping anything that looks like an ad: boxes in the right rail, animated panels, and content styled with promotional colors or stock photos. The visual system learns which shapes are noise for the task and stops looking at them.

Banner blindness spreads beyond ads. Any element that repeatedly offers nothing useful becomes invisible: the "What's new" panel, the persistent upgrade bar, the tips sidebar. Worse, when you later put something important in that place or style, it inherits the blindness.

Don't
IMPORTANT Export will stop working on 1 March
Looks like an ad, treated as an ad. Right-rail, bright box, promotional style: the very things that trained users to ignore ads.
Do
CSV export ends on 1 March. Use the new Markdown export instead. Export
Content-styled, at the point of use. Written like content, placed exactly where the export decision happens.

Designing for one locus

  • Put feedback where attention already is. Raskin's strongest practical advice: messages belong at the locus, not in a status bar people never read.
  • Avoid modes the user must remember. Raskin argued that modes cause errors because the mode indicator is never at the locus; you type expecting one behavior and get another (the Caps Lock problem).
  • Remove instead of styling. Each element costs filtering effort even when ignored. Removing a permanent banner frees more attention than making it subtler.

Do

  • Show status, errors and confirmations at the element the user just acted on.
  • Style important notices as content, in the flow, near the related action.
  • Remove persistent promotional elements; use one-time, contextual moments instead.
  • Make modes visible at the locus (a cursor that changes, a colored frame).

Don't

  • Put critical information in an ad-like box, right rail or carousel.
  • Use the same banner slot for promotions and for important warnings.
  • Rely on a status bar for anything people must notice.
  • Add "just one more" persistent element without removing another.

In the wild

  • Vim and modal editorsa classic case
    Powerful, but the mode indicator lives in the bottom line, away from the cursor, and new users type commands as text. Raskin's warning about modes in its purest form; experts survive it by making mode-switching automatic.
  • SuperhumanSuperhuman, 2017–
    Shows one email at a time in focus, with keyboard commands surfaced in place (a command palette) rather than toolbars. Designed around a single locus.
  • iA Writer Focus ModeInformation Architects
    Dims everything except the current sentence or paragraph. The interface literally draws the locus of attention.

Common mistakes

The announcement banner that never leaves

It was added for a launch and nobody removed it.

Give every non-task element an expiry date and a dismiss that remembers.

Feedback in the corner

Corners are free space, so toasts and status go there.

Ask "where are the eyes at this moment?" and put feedback there.

Promotional styling for real information

You want it noticed, so you make it loud.

Loud and ad-shaped is skipped. Make it relevant, close and plainly written instead.

Check yourself

You need users to know that their free trial ends in 3 days. You have a colored banner across the top of every page, and nobody reacts to it. What is most likely to work?

Exercise 6.1 30 minutes · on your own product

Map the locus

  1. Pick your product's core task and break it into 5–8 steps.
  2. For each step, mark on a screenshot where the user's locus of attention is.
  3. Mark every piece of feedback, status or message the product shows during that step.
  4. Draw an arrow from each message to the locus. Long arrows are problems.
  5. Move the message with the longest arrow next to the locus.
You're done when: you have an annotated step-by-step strip with arrows and one moved message in code.
BeginnerCompetentStrong
Locus marked per step.Distant feedback found and moved.Persistent non-task elements removed or given an expiry, and you can justify each survivor.
7

How people scan: F, layer-cake, spotted and Z

Taught by Jakob Nielsen, with Kara Pernice and Steve Krug

People rarely read screens; they scan for words that match their goal. Where they scan depends on how the page is structured, and when the page gives them nothing to grab, they fall back to the worst pattern: the F.

Nielsen's 2006 eye-tracking study of web pages produced the famous F-shaped pattern: two horizontal sweeps across the top, then a vertical scan down the left edge. Nielsen Norman Group's 2017 follow-up, by Kara Pernice, made the important correction that is often lost: the F-pattern is a symptom of poor structure, not a goal. People fall into it when text has no headings, bold keywords or lists to anchor on. The same research described other patterns: layer-cake (eyes jump from heading to heading, reading body text only under relevant ones), spotted (skipping around for a specific word, number or link), and commitment (reading everything, when motivation is high).

F-pattern wall of text, no anchors Layer-cake clear headings and chunks Spotted hunting for a price or date ₹ 499 12 May 30 days Schematic, not real data. Shaded areas show where fixations concentrate in each pattern as described by Nielsen Norman Group.
Structure decides the pattern. The same reader produces an F on a wall of text and a layer-cake on a page with meaningful headings. Numbers, dates and bold words become fixation magnets in spotted scanning.

What about the Z-pattern?

The Z-pattern (eyes go top-left to top-right, diagonally down, then across the bottom) and its cousin the Gutenberg diagram are layout heuristics for sparse pages with few elements, like a landing page hero or a poster. They are not strong eye-tracking findings in the way the F and layer-cake are. Use them as a composition idea (logo top-left, action bottom-right, a strong diagonal), not as a law. On dense, text-heavy screens, scanning follows content structure, and the Z disappears.

Watch out

All of these patterns are for left-to-right languages. In Arabic, Hebrew or Urdu interfaces the patterns mirror. And on phones, a single column turns most scanning into a vertical pass: headings and the first words of each line carry nearly all the weight.

Design for the layer-cake

  1. Write headings that carry meaning. "Export your notes as Markdown" beats "Export". A scanner reads only the heading; it must answer "is this for me?".
  2. Front-load. The first two words of every heading, list item and link do most of the work, because scanning eyes fixate on the left edge.
  3. Chunk body text short. Two to four sentences per paragraph, one idea each.
  4. Make the scannable things look scannable: bold key terms sparingly, numbers as digits ("3 days", not "three days"), lists for parallel items.
  5. Put the action next to the explanation, not in a different region, so the layer-cake reader finds it in the same chunk.

Writing for scanning is covered deeply in Words and Reading & Writing. Here the lesson is perceptual: the eye goes to anchors, and you decide where the anchors are.

Do

  • Give every screen of text descriptive headings people can scan alone.
  • Start labels, list items and links with the distinguishing word.
  • Use digits for numbers in UI.
  • Test by reading only headings and bold text: does the page still make sense?

Don't

  • Write clever headings that hide the topic ("A new chapter").
  • Start every list item with the same words ("Click here to…").
  • Assume the Z-pattern will guide eyes on a dense screen.
  • Bold half the paragraph.

In the wild

  • GOV.UKGovernment Digital Service, 2012–
    Short pages, plain descriptive headings, front-loaded link text, numbers as digits. A whole service built for the layer-cake reader.
  • Stripe DocsStripe
    Each section starts with a heading that names the task, followed by a short paragraph and a code block. Developers scan for their task, read one chunk, copy the code.
  • Apple Settings search resultsApple
    Results show the setting name first and its location path in smaller gray text. Front-loading the distinguishing word supports spotted scanning.

Common mistakes

Treating the F as a template

"Users read in an F, so put important things on the left" is a misread of the research.

Treat the F as a warning sign. Add structure so people can scan in layers instead.

Same-start labels

"Settings for account", "Settings for sync", "Settings for export".

Lead with the distinguishing word: "Account", "Sync", "Export".

Check yourself

Your app's changelog is a long list of paragraphs. Users say "I never know what changed". Eye-tracking would most likely show which pattern, and what is the fix?

Exercise 7.1 30 minutes · on your own product or site

The headings-only test

  1. Take your landing page, help page or any text-heavy screen.
  2. Copy only the headings, bold text and link text into a blank document, in order.
  3. Ask: could someone decide what to do from this alone?
  4. Rewrite headings and the first words of list items until the answer is yes.
You're done when: the extracted "skeleton" reads as a coherent summary, and the page is updated.
BeginnerCompetentStrong
Skeleton extracted.Headings rewritten to carry meaning.Every list item and link front-loaded; tested by timing someone finding a specific fact.
8

Interruptions, notifications and flow

Taught by Mihaly Csikszentmihalyi, with Gloria Mark, Mark Weiser and Amber Case

Deep work happens in a fragile state called flow. Every interruption breaks it, and getting back costs far more than the interruption itself. A product that respects attention protects flow and batches everything else.

Mihaly Csikszentmihalyi studied people at their best, painters, chess players, surgeons, rock climbers, and described flow in his 1990 book Flow: The Psychology of Optimal Experience: total absorption in an activity, loss of self-consciousness, distorted sense of time. Flow appears under specific conditions: a clear goal, immediate feedback, and a balance between challenge and skill. Too easy and people get bored; too hard and they get anxious.

Challenge Skill Flow channel Anxiety too hard, too much at once Boredom too easy, too slow new userregularexpert
A good tool keeps the user in the channel as they grow. Progressive disclosure, shortcuts and advanced options let challenge rise with skill. After Csikszentmihalyi's flow model.

The cost of an interruption

Gloria Mark at UC Irvine has studied interruptions in real offices since the early 2000s. Her field work found that people switch activities every few minutes and that interrupted work is often not resumed for a long time; the popular figure of "about 23 minutes to get back on task" comes from her research and interviews. In a 2008 lab study, Mark, Gudith and Klocke found something subtler: interrupted people completed tasks in about the same time, but by working faster, with significantly more stress, frustration and effort. Interruptions do not just cost time; they cost wellbeing.

Notifications are interruptions you design. Each one asks the user to move their locus of attention from their task to yours. The design question is always: is this worth breaking what they are doing right now?

Focused writing session deep work ping recovering context deep work The notification takes seconds. Rebuilding what you held in working memory (where you were, what came next) takes much longer, and some tasks are never resumed. Schematic proportions.
The visible cost is small; the hidden cost is large. Interruptions empty working memory (chapter 9), and people pay to refill it.

Calm notification design

Mark Weiser and John Seely Brown at Xerox PARC proposed "calm technology" in 1995: technology that informs without demanding focus, moving easily between the periphery and the center of attention. Amber Case turned it into principles in her 2015 book Calm Technology. In practice for notifications:

LevelWhenHowExample
Interrupt nowTime-critical and personalPush with sound, only on explicit opt-inA ride has arrived; 2FA code
Notify quietlyRelevant soon, not urgentSilent notification, badgeA friend commented
BatchUseful in aggregateDaily or weekly digestNew highlights this week
AmbientStatus that changes slowlyShown in the UI when opened, no pushSync status, storage used
NeverExists to bring the user backDo not send"We miss you!"
Don't
9:41 Streak at risk! New feature! We miss you 50% off today Tip of the day
Five interruptions, zero value. Each costs a context switch. The likely response is "turn off all notifications", which also kills the one that mattered.
Do
9:41 Anu shared a note"Trip plan" · reply? Sunday: weekly digest everything else
Personal and actionable, or batched. One interruption from a person, everything else in a digest the user chose.

Do

  • Default notifications to off or minimal, and let people opt in by type.
  • Batch non-urgent updates into digests.
  • Let people resume exactly where they were (cursor, scroll, selection).
  • Design challenge to grow with skill: shortcuts, advanced options revealed over time.

Don't

  • Send re-engagement notifications that serve your metrics, not the user.
  • Interrupt a user mid-task with a survey, rating prompt or tip.
  • Lose the user's place after an interruption.
  • Keep beginners and experts on the same fixed difficulty.

In the wild

  • iOS Focus and Notification SummaryApple, iOS 15, 2021
    Let people silence apps by context and deliver non-urgent notifications in a scheduled summary. The platform now batches for you; design notifications that make sense in a summary.
  • Slack Do Not Disturb and scheduled sendSlack
    Senders can schedule messages for working hours and recipients can pause notifications. Both sides of an interruption get control.
  • KindleAmazon, 2007–
    The reading screen shows almost nothing but the page; progress and menus appear only on tap. A reading device built for flow: clear goal, no interruptions, immediate page-turn feedback.
For the solo creator

Re-engagement notifications are tempting when you are watching retention alone at 1 a.m. Resist. A small product lives on trust and word of mouth; a reputation for being calm is a competitive advantage big companies cannot copy easily. Build one well-designed digest instead of many pings. It is also less code to maintain. The ethics side is in Honest & Calm.

Common mistakes

Rating prompts mid-task

The prompt fires on the third launch, regardless of what the user is doing.

Ask only after a success moment, at a natural pause, and rarely (iOS limits the system rating prompt to three times a year per app).

All or nothing notification settings

One toggle is easier to build.

Offer categories, so people can keep the useful ones instead of turning everything off.

Lost place

State is not saved on backgrounding.

Persist cursor, scroll position, open panels and drafts; resuming should cost nothing.

Check yourself

Your writing app shows a "Did you know?" tip in a popover 30 seconds after the user starts typing. Engagement with tips is high (many clicks), but session length dropped. What is happening?

Exercise 8.1 40 minutes · on your own product

Notification triage

  1. List every notification, email, badge, popover and in-app message your product can send.
  2. Put each in a level from the table above (interrupt, quiet, batch, ambient, never).
  3. For each "interrupt", write the user benefit in one sentence. If you cannot, demote it.
  4. Delete everything in "never". Design one digest for the "batch" items.
You're done when: you have a triage table, and at least one notification removed or demoted in your code.
BeginnerCompetentStrong
Everything listed and levelled.Demotions made; "never" items deleted.Digest designed and per-category settings shipped, defaulting to the calm option.
Part two recap: connect the ideas

Your app's important "Unsaved changes" warning appears in a colored strip at the top of the window, and users still lose work. Using Parts one and two, what is the strongest explanation?

Part three

Memory: the tiny desk and the huge library

Working memory is a small desk where you hold what you are thinking about right now: a few items, gone in seconds unless rehearsed. Long-term memory is a vast library of facts, habits and models, slow to write and sometimes hard to find. Good interfaces keep the desk clear and lean on what is already in the library.

9

Working memory: seven, four, and chunks

Taught by George A. Miller, with Nelson Cowan, Alan Baddeley and John Sweller

People can hold only about four meaningful chunks in mind at once, for a few seconds. Never make them carry information from one screen to another, and when they must handle long strings, chunk them.

In 1956 George Miller published "The Magical Number Seven, Plus or Minus Two: Some Limits on Our Capacity for Processing Information" in Psychological Review. The paper is witty and careful. It reviewed two kinds of limits: how many categories people can reliably distinguish on one dimension (absolute judgment, around seven), and how many items people can repeat back in order (immediate memory span, also around seven). Miller pointed out that the coincidence might be "only a pernicious, Pythagorean coincidence". His most lasting idea was chunking: memory span is limited in chunks, not in raw bits, so recoding information into bigger meaningful units extends what we can hold.

In 2001 Nelson Cowan reviewed decades of later research in "The magical number 4 in short-term memory" (Behavioral and Brain Sciences). When you stop people from rehearsing and grouping, the true capacity of the focus of attention is about 3 to 5 chunks, typically 4. Seven was the span with rehearsal and chunking helping.

Myth

"Menus and navigation must have seven items or fewer because of Miller." No. Visible items are not held in working memory; they are on screen to be re-read. Miller's paper says nothing about menus. The legitimate design uses of working-memory limits are: what people must remember between steps, how many things they must compare in their head, and how long strings they must copy. A navigation bar with 9 clear items can be fine; a flow that asks you to remember a 6-digit code from another app is not.

Central executive directs attention Phonological loop words, numbers, sounds Episodic buffer binds into episodes Visuospatial sketchpad where things are, shapes Long-term memory: knowledge, habits, mental models (huge, slow to write)
Working memory is several small stores, not one. After Baddeley and Hitch (1974), with the episodic buffer added by Baddeley in 2000. Holding a code in the phonological loop while also navigating visually is possible, but both stores are small.

Chunking: making four go further

A chunk is a unit that is meaningful to the person. "9 8 7 6 5 4 3 2 1 0" is ten digits but one chunk ("counting down"). An unfamiliar 10-digit string has ten. Formatting helps people build chunks: grouping digits by 3 or 4, using separators, keeping known structure (country code, area code) visible. This is why phone numbers, credit cards and IBANs are printed in groups.

Lab: read it, hide it, type it
Press Show code
The code shows for 4 seconds, then disappears. Alternate between unchunked and chunked at the same length (try 12). Most people recall noticeably more characters when the code is grouped, even though the information is identical. Scoring counts correct characters in position.
Don't
Bank account (IBAN)
GB29NWBK60161331926819
22 characters, no structure. People lose their place copying it, and errors are hard to spot.
Do
Bank account (IBAN)
GB29 NWBK 6016 1331 9268 19
Groups of 4, the standard print format for IBANs. Each group is one chunk to check.
Do
Enter the code we sent
482913
Autofilled from Messages
OTP in two groups of 3, and better still, autofilled so nothing is held in memory at all.

The example IBAN above is the standard sample number used in documentation, not a real account.

Cognitive load: three kinds

John Sweller's cognitive load theory (from 1988, developed through the 1990s) divides the mental effort of a task into three kinds. Intrinsic load comes from the task itself: splitting a bill among five people with different shares is inherently harder than splitting it equally. Extraneous load comes from how the task is presented: hunting for a field, decoding jargon, remembering a value from a previous screen. Germane load is effort that builds lasting understanding (learning how the tool's model works). Later versions of the theory folded germane load into intrinsic, but the design rule survives: you cannot remove intrinsic load, you must ruthlessly remove extraneous load, so people's limited working memory goes to their actual problem.

Cluttered flow intrinsic (the task)extraneous (the UI) Clean flow room to think and learn The capacity is fixed. Design changes only how much of it the interface wastes.
The fixed box. Every unnecessary field, unclear label or remembered value takes space that the user's actual problem needed.

Do

  • Carry information forward: show the values from step 1 on step 3.
  • Format long strings in groups (3–4 characters) and allow pasting with or without spaces.
  • Autofill codes, addresses and payment details wherever the platform allows.
  • Keep comparisons side by side instead of across screens or tabs.

Don't

  • Ask people to remember a code, number or name from another screen or app.
  • Cite "7±2" to justify cutting a visible menu.
  • Split one decision across several modal steps when its inputs belong together.
  • Reject input because the user typed spaces or dashes in a chunked number.

In the wild

  • iOS and Android OTP autofillApple iOS 12, 2018; Android SMS Retriever
    Codes received by SMS are offered above the keyboard. The best working-memory design is the one that holds nothing.
  • Stripe Elements card fieldStripe
    Formats the card number into groups of four as you type and detects the brand. Chunking applied live, plus Postel's law (chapter 18): it accepts what you type and formats it.
  • UPI payment screensIndia, NPCI ecosystem
    Good UPI apps show the payee's registered name after you enter a UPI ID, before you pay. Recognition replaces having to remember and verify a string yourself.

Common mistakes

The remember-and-retype flow

Data lives in another screen or app and it is easier to ask than to integrate.

Show the needed value on the screen where it is needed, offer copy buttons, or deep-link with the value filled in.

Strict input masks

The validator expects exactly 16 digits, so spaces fail.

Strip separators on input, display chunked, store raw.

Misused 7±2

It is the most famous number in UX.

Use ~4 chunks as the limit for things people must hold in mind; judge visible lists by scanning cost instead.

Check yourself

Your app's referral flow says "Copy your 10-character code, then go to Settings → Invite and paste it". People make errors. Which change best reduces working memory load?

Exercise 9.1 45 minutes · on your own product

Memory-load inventory

  1. Walk through your core flow. At every step, write down what the user must remember from earlier (values, choices, names, where they came from).
  2. Count the items held at each step. Mark any step above 3.
  3. For each held item, choose: carry forward on screen, autofill, remove, or chunk.
  4. Implement the fix for the step with the highest count.
You're done when: you have a step-by-step memory-load table and the worst step redesigned so it holds at most one item.
BeginnerCompetentStrong
Held items listed.Load counted and the worst step fixed.Separated intrinsic from extraneous load for the whole flow and removed all extraneous holds.
10

Recognition over recall, and mental models

Taught by Don Norman, with Jakob Nielsen, Kenneth Craik and Endel Tulving

Recognizing something you see is far easier than recalling it from nothing. And people operate your product through a mental model, a private simplified theory of how it works, which your interface either teaches correctly or teaches wrong.

Ask someone to name all the menu items in their email app and they will struggle. Show them the menu and they will instantly know which one they want. Recognition needs only a match between what you see and what you know; recall must reconstruct the item from scratch with only a vague cue. This is why graphical interfaces beat command lines for occasional use, and why Nielsen made "recognition rather than recall" one of his ten usability heuristics (1994).

Don't
Filter tasks e.g. tag:waiting due:<7d Syntax: see documentation. Which tags exist? Recall them.
Recall. Users must remember tag names and query syntax. Experts love it; everyone else is stuck.
Do
Filter tasks wai| Tag: Waiting (12) Recent: Due this week Recent: Waiting + Work
Recognition. Typing three letters shows existing tags and recent filters. The syntax still works for experts.

Recognition patterns you can use

  • Visible options instead of hidden commands: menus, toolbars, a command palette that lists actions as you type.
  • Recent and frequent items: recent files, recent searches, recently used emoji.
  • Autocomplete and previews showing actual content (file thumbnails, link previews).
  • Keyboard shortcuts shown next to menu items, so recognition slowly trains recall for those who want speed.
  • Breadcrumbs and titles that tell people where they are, so they do not have to remember how they got there.

Long-term memory: kinds that matter for design

Endel Tulving distinguished episodic memory (events you lived) from semantic memory (facts you know); researchers also describe procedural memory (skills and habits). For interfaces: semantic memory holds conventions ("trash can deletes"), procedural memory holds motor habits ("Cmd-S saves"), and episodic memory holds the experience ("last time this app lost my draft"). You build on the first, must not break the second (chapter 11), and are judged by the third (chapter 17).

Mental models: the theory in the user's head

The Scottish psychologist Kenneth Craik suggested in 1943 that the mind builds "small-scale models" of reality to predict what will happen. Don Norman applied this to design in The Design of Everyday Things with three models: the designer's model (how you think it works), the system image (what the product shows: UI, words, behavior, docs), and the user's model (what they infer). You never talk to the user directly. Everything they learn comes through the system image, so if the system image is unclear or inconsistent, the user builds a wrong model, and then makes "errors" that are perfectly logical given that model.

Designer'smodel System image UI, words, behavior User'smodel no direct channel: you are not in the box with them
The system image is your only voice. After Norman, The Design of Everyday Things. If the user's model is wrong, fix the system image, not the user.

Common broken models

ProductUsers often believeRealitySystem-image fix
Cloud syncDeleting a local file just frees spaceIt deletes everywhereSay "Delete from all devices" in the confirmation
ThermostatSetting it higher heats fasterMost heat at one rateShow "Heating to 22°, about 15 minutes"
Shared doc linkOnly people I sent it to can open itAnyone with the link canShow who can access, in words, next to the link
"Archive" in mailArchive deletesArchive files away, still searchableBrief first-time confirmation; "Archived. Find it in All Mail"

Do

  • Show options, recent items and previews instead of making people remember.
  • Name things by the user's model, not your database ("Trash", not "soft-deleted").
  • Make consequences visible before an action ("This removes it from 3 devices").
  • Keep behavior consistent so the model stays simple.

Don't

  • Hide frequent actions behind syntax or gestures only.
  • Expose implementation concepts the user does not need (sync queues, object IDs).
  • Let one action behave differently in different places.
  • Blame "user error" when many users make the same mistake.

In the wild

  • Raycast and command palettesRaycast; VS Code; Linear
    Type a few letters and see every matching action with its shortcut. Recognition-based access to a recall-based world; the shortcut labels gradually teach recall.
  • DropboxDropbox, 2008
    Made sync feel like "a folder on your computer", matching the model people already had of files and folders. Borrowing an existing mental model is faster than teaching a new one.
  • Gmail Undo SendGoogle, Labs 2009, default 2015
    Gmail cannot unsend an email that has left; it delays sending by a few seconds. Users' model ("I can unsend") is wrong, but the system makes it effectively true. Sometimes you change the system to fit the model people already have.

Common mistakes

Designer's model leaking through

You named things after your code.

Write a glossary of user-facing nouns from user interviews or support emails and use only those.

Hidden power features

Gestures and shortcuts feel elegant and save screen space.

Every hidden action needs a visible path too (a menu item, a palette entry).

Check yourself

Support emails for your photo app say "I deleted photos to free up space on my phone and now they're gone from my laptop too!" What is the best fix?

Exercise 10.1 50 minutes · with one other person

Draw their model

  1. Ask a friend who uses your product (or a similar one) to draw, on paper, "how it works": where their data is, what happens when they save, delete, share.
  2. Draw your own designer's model next to it.
  3. Circle every difference. For each, find what in the system image taught the wrong idea.
  4. Change one label, message or confirmation so the system image teaches the right model.
You're done when: you have both drawings side by side with differences circled, and one system-image change shipped.
BeginnerCompetentStrong
Both models drawn.Differences traced to specific UI.Fix shipped and re-checked with a second person.
11

Habit, position and the unfinished

Taught by Jef Raskin, with Hermann Ebbinghaus, Bennet Murdock and Bluma Zeigarnik

Repeated actions become automatic habits that run without attention, so moving a control breaks people in a way no amount of explanation fixes. Memory also favors the first and last items in a sequence. And unfinished tasks pull at us, though less magically than the internet claims.

Habituation and muscle memory

Raskin argued that every interface eventually becomes habitual, and that this is a good thing: habits free the locus of attention for the real work. A writer who saves with Cmd-S does not think about saving. But habits run on location and sequence, not meaning. If you move "Save" or reorder a tab bar, the habit fires anyway and lands on the wrong thing. People do not just get slower; they make errors, feel stupid, and blame the product.

Habits also defeat confirmation dialogs. When "Are you sure?" appears every time, the click on "Yes" joins the habit, and the dialog stops protecting anything. Raskin's alternative: make actions undoable instead of confirmable.

Before HomeSearchNew postActivityProfile After the redesign HomeSearchVideosShopProfile the thumb still goes here
Habits follow position, not labels. Schematic of a common redesign pattern: a new feature takes the most-used slot, and every habitual tap now lands on it.

Serial position: first and last stick

Ebbinghaus noticed it in the 1880s and Bennet Murdock measured it cleanly in 1962: when people try to recall a list, they remember the first few items (primacy, which had more rehearsal and reached long-term memory) and the last few (recency, still in working memory) much better than the middle. The effect is robust. Try it.

Lab: the serial position curve
Ready
12 words appear one at a time, about one per second. Then type all you remember.
123456789101112
Bars show how often you recalled the word at each position across rounds. After three or four rounds, most people see a U: high at the start, high at the end, low in the middle. Each round uses a fresh random set of everyday words.

Design uses: put the most important items of a list, a tab bar or an onboarding sequence at the start and end. In a short tab bar, the first and last positions are both the most memorable and the easiest to reach. In a long settings list, the middle is where rarely-needed items belong. In a pitch or a landing page, the opening and the final summary carry the most weight.

The Zeigarnik effect, honestly

In 1927 Bluma Zeigarnik, working in Kurt Lewin's lab in Berlin, reported that people remembered interrupted tasks better than completed ones. Her colleague Maria Ovsiankina (1928) found a related effect: people tend to spontaneously resume interrupted tasks. Product writing often cites "Zeigarnik" to justify progress bars, incomplete profile meters and cliffhangers.

The evidence is weaker than that story suggests. Replications over the decades were mixed, and a 2025 meta-analysis by Ghibellini and Meier found no general memory advantage for unfinished tasks, while the urge to resume them (the Ovsiankina effect) held up better. The safe design reading: people do feel a pull to complete open, visible tasks, especially ones they chose and that are nearly done (see goal-gradient in chapter 17). Do not rely on a memory effect to make people return.

Do

  • Keep positions of frequent controls stable across versions.
  • When you must move something, leave a signpost at the old location for a while.
  • Offer undo instead of habitual confirmation dialogs.
  • Place the most important items first and last in lists and sequences.
  • Show unfinished work the user chose to start ("Continue your draft").

Don't

  • Put a new feature in the slot of an old, frequently used one.
  • Reorder menus by usage automatically (adaptive menus break habits).
  • Rely on "Are you sure?" for destructive actions people do often.
  • Manufacture fake unfinished tasks ("Your profile is 60% complete!") to nag.

In the wild

  • Instagram tab barMeta, November 2020
    Reels took the center tab, Shop took the activity tab, and the new-post button moved to the top. Many users reported tapping the wrong tab out of habit. A redesign that prioritizes business goals over habit pays in frustration.
  • Safari 15 for Mac (beta)Apple, 2021
    The beta merged tabs and the address bar into a compact design; after feedback, Apple made the traditional separate layout available again before release. Even a well-reasoned change can collide with years of habit; keep an escape hatch.
  • Microsoft Office "personalized menus"Office 2000
    Menus hid rarely used items and reordered by use. The adaptive menus were widely disliked and were dropped with the 2007 Ribbon. Adaptive layouts break spatial memory; stability beats cleverness.
For the solo creator

Your early users have habits too, even with a small product. Before any layout change, write down the top five actions by frequency and make sure none of them move. If one must move, ship the move with a one-time hint at the old location, and keep the old keyboard shortcut working forever. You will save yourself a week of support emails.

Common mistakes

The prime-slot land grab

The new feature needs visibility, and the best slot is taken by an old one.

Introduce new features in place of rarely used items, or with a one-time, dismissible prompt.

Confirmation fatigue

Every delete asks "Are you sure?".

Delete immediately, show "Deleted. Undo" near the action, and keep items in a trash for 30 days.

Treating Zeigarnik as a growth hack

A popular article said incomplete tasks are remembered.

Use progress to help people finish what they chose to do, not to manufacture obligations.

Check yourself

Your journaling app has five bottom tabs: Today, Calendar, Search, Insights, Settings. You want to add "Prompts" and expect it to be popular. Where does it go?

Exercise 11.1 30 minutes · on your own product

A habit map

  1. From analytics or your own memory, list the 10 most frequent actions in your product.
  2. For each, note its position (screen, region, order) and its shortcut.
  3. Mark which ones changed position in your last three releases.
  4. Write a "stability contract": the positions and shortcuts you promise not to change without a migration hint.
You're done when: you have a habit map and a written stability contract in your project notes.
BeginnerCompetentStrong
Top actions listed.Positions and changes recorded.Contract written and one past break repaired (a restored shortcut or a signpost).
Part three recap: connect the ideas

A new two-factor setup asks users to scan a QR code, then on the next screen type the 6-digit code from their authenticator app before it expires in 30 seconds, then on a third screen copy ten recovery codes. Which ideas from Parts two and three apply?

Part four

Decision and action: the laws of choosing and doing

This is where most "laws of UX" live. Some are mathematical models with decades of lab support (Fitts, Hick). Some are well-replicated findings from behavioral economics (defaults, loss aversion, peak-end). Some are wise rules of thumb wearing a lab coat (Parkinson, Pareto, Tesler). Each chapter tells you which is which, because applying a rule of thumb as if it were physics is how designers go wrong.

12

Hick's law: more choices, slower decisions (sometimes)

Taught by William Edmund Hick, with Ray Hyman and Thomas Landauer

The time to choose among equally likely options grows with the logarithm of how many there are. It is a real law, but only for a narrow kind of choice; for scanning lists and making real-life decisions, other things matter more.

In 1952 W. E. Hick and in 1953 Ray Hyman showed that when people must respond to one of several lights by pressing the matching key, reaction time rises by a constant amount each time the number of equally likely alternatives doubles. The usual form is T = a + b · log₂(n + 1). Going from 2 to 4 options adds about as much time as going from 4 to 8, or 8 to 16. The log means the cost grows slowly: doubling the options does not double the time.

Decision time Number of equally likely choices 1481630 Each doubling adds the same small step (schematic).
The log curve. The steep part is between 1 and about 8 options. After that, extra options cost little decision time, as long as people can find them.

When Hick's law applies, and when it does not

Hick's experiments measured a specific situation: options are equally likely, the person knows them all, and the mapping from stimulus to response is learned. Interfaces often differ:

  • Unfamiliar lists are searched, not decided. When you do not know where an item is, you scan, and scan time grows roughly linearly with the items you must look at. Sorting, grouping and search cut this.
  • Familiar, ordered lists become log-like again. Landauer and Nachbar (1985) found menu selection in well-ordered menus (alphabetical or numeric) fit a log relationship: you can jump to roughly the right place.
  • Practice flattens it. Experts with a fixed layout pick by location from memory.
  • Unequal likelihoods change everything. If one option is chosen 80% of the time, making it the obvious default removes the decision for most people.

So the practical reading is not "fewer options are always better". It is: reduce the number of options that must be considered at each moment, by defaults, grouping, progressive disclosure and good ordering, while keeping everything findable.

Lab: find it in the menu
Press Start, then click the requested item.
Do a few trials at 4, 16 and 32 items in each order. With alphabetical order, time grows slowly (you jump to the letter). With random order, it grows much faster, because you are scanning one by one. That gap is the honest lesson: order and grouping often matter more than the count.
Don't
Export as… RTFePubODT LaTeXPDFOPML HTMLJSONWord TextileMarkdownCSV 12 equal options, random order
Everything weighs the same. The two formats 90% of people want are lost among rare ones.
Do
Export as… PDF Markdown Word More formats (9) › alphabetical inside
Weighted by likelihood. One default, two alternatives, the rest one tap away, sorted. Nothing removed, decisions cut.

Do

  • Order long lists predictably (alphabetical, chronological, by frequency) so people can jump.
  • Promote the one or two most likely choices; tuck the rest behind "More".
  • Group options under meaningful headings.
  • Offer search when a list exceeds about 15–20 items.

Don't

  • Cut useful options just to hit a small number.
  • Present a long, unsorted list where every item has equal weight.
  • Quote Hick's law to justify hiding things people need often.
  • Ask people to decide at moments when a default would do.

In the wild

  • Google homepageGoogle, 1998–
    One field, two buttons, and most people use only the field and Enter. The famous minimalism is a near-zero decision cost at the moment of arrival.
  • iOS share sheetApple
    Suggested people and recent apps come first; the long list of actions is below and editable. Likelihood ordering beats fewer options.
  • Apple Pay / Google Pay buttonsApple, Google
    At checkout, one prominent button replaces choosing card, address and shipping separately. A smart default collapses many choices into one.

Common mistakes

Counting instead of weighting

"Keep it to 5 items" is easy to measure.

Measure how often each option is used, and design weight in proportion.

Hidden essentials

Over-applied simplification moves a daily action into "More".

Check usage data: anything most users need weekly stays visible.

Check yourself

Your settings screen lists 40 options in the order you added them. A teammate (you, last week) proposes removing 20 to "follow Hick's law". What is the better move?

Exercise 12.1 35 minutes · on your own product

Weight the choices

  1. Find the menu, picker or screen in your product with the most options.
  2. Estimate (or measure) the share of use for each option.
  3. Redesign it: one default or primary, a few secondary, the rest behind "More" or grouped and sorted.
  4. Time yourself finding three rare items before and after, to check you did not make them unfindable.
You're done when: you have a usage-weighted redesign and before/after find times for both common and rare items.
BeginnerCompetentStrong
Options listed with estimated use.Redesign weights by likelihood.Common items faster, rare items no slower; measured.
13

Fitts's law: bigger and closer is faster

Taught by Paul Fitts, with I. Scott MacKenzie, Bruce Tognazzini and Steven Hoober

The time to hit a target depends on how far away it is and how big it is. Make frequent targets large and close, use screen edges and corners, and put touch targets where thumbs can reach.

Paul Fitts, a US Air Force psychologist, published the law in 1954 from experiments where people tapped back and forth between two metal plates. Movement time rises with an "index of difficulty" based on the ratio of distance to width. The formulation most used in HCI today is MacKenzie's (1992): MT = a + b · log₂(D/W + 1), where D is distance to the target's center and W is the target's width along the direction of movement. It is one of the most robust laws in human-computer interaction; it holds for mice, trackpads, fingers, styluses and even eye-gaze pointing, with different constants.

start D 100, W 30: easy (ID ≈ 2.1) D 300, W 60:also easy (ID ≈ 2.6) D 400, W 12: hard (ID ≈ 5.1), slow and error-prone
Ratio, not distance alone. A far target can be as quick as a near one if it is proportionally bigger. Small and far is the worst case. ID = log₂(D/W + 1), in bits.
Lab: Fitts click test
Click Start, then click the yellow target as fast as you can. Each trial randomizes size and distance.
Do 15 to 20 trials. The log groups your times by difficulty (easy, medium, hard). Hard targets (small and far) should take clearly longer, and you will miss them more. That is why a 16 px icon button in a far corner of a big window feels sluggish even though it is "right there".

Edges and corners: infinitely large targets

On a desktop, the pointer stops at the screen edge. A target that touches the edge is effectively infinitely deep in the direction of movement: you can throw the mouse at it without aiming. Corners are best of all, capped in two directions. Bruce Tognazzini, Apple's early human interface evangelist, popularized this, calling the four corners the easiest targets on screen after the pixel under the cursor. It is why the Mac menu bar sits at the very top edge of the screen, and why hot corners work. A window-attached menu bar a few pixels below the edge loses the effect.

menu bar on the edge: overshoot-proof floating toolbar: must aim Corners: capped intwo directions, thefastest targets. Edges: one directionis infinite, so throwthe pointer.
The edge stops the pointer for you. Only true on desktop with a mouse or trackpad. On touch screens, edges have no special advantage for taps (and are often reserved for system gestures).

Thumbs: Fitts on a phone

On touch screens, distance is measured from where the thumb rests, and target width is limited by the finger's contact area. Steven Hoober's 2013 observation study of 1,333 people using phones in public found about 49% using one hand, 36% cradling the phone, and 15% two-handed. Josh Clark's "thumb zone" diagrams (in Designing for Touch, 2015) mapped what one-handed users can reach comfortably. Today's phones are tall, so the top of the screen is the hardest place to reach, which is why many apps have moved key actions and even search fields toward the bottom.

Hardstretch or regrip OK Easy Put rare and destructiveactions up here Primary actions, tab bar,compose, bottom sheets Right-hand grip.Mirror for left hand,so center-bottom issafest for both.
Thumb reach, schematic. After Hoober's observations and Clark's thumb-zone diagrams. Exact zones vary by phone size and hand; the bottom-center is reliably easiest and the top-left (for right-handers) is hardest.

Minimum sizes

GuidelineMinimum targetNote
Apple Human Interface Guidelines44 × 44 ptFor iOS and iPadOS touch targets
Material Design48 × 48 dpVisual icon can be smaller; the hit area is 48
WCAG 2.2, 2.5.8 (AA)24 × 24 CSS pxOr enough spacing around smaller targets
WCAG 2.2, 2.5.5 (AAA)44 × 44 CSS pxThe enhanced level

The visible shape can be smaller than the hit area. A 20 px icon can sit in a 44 px invisible tap target. Spacing matters too: two 44 px targets touching each other still cause mis-taps; leave at least 8 px between destructive and safe actions.

Don't
savedelete 16 px targets, 4 px apart, far corner
Small, far, adjacent. Slow to hit, and a slip deletes instead of saves.
Do
Save ··· Delete lives in ··· with undo
Big, close, separated. The frequent action is large and next to the content; the destructive one is out of slip range.

Do

  • Make frequent targets big, and put them near where the pointer or thumb already is.
  • Make entire rows and cards clickable, not just the text inside.
  • Use edges and corners for important desktop targets.
  • Put context menus at the pointer (distance zero).
  • Give frequent actions a keyboard shortcut: no pointing at all.

Don't

  • Make tap targets smaller than 44 pt / 48 dp on touch screens.
  • Put destructive actions next to frequent ones.
  • Place primary phone actions in the top-left corner.
  • Add a few pixels of margin between a target and the screen edge (it kills the infinite edge).

In the wild

  • macOS menu barApple, 1984–
    Always at the top screen edge, regardless of window position. Infinite-depth targets for the most frequent commands.
  • Safari on iPhoneApple, iOS 15, 2021
    Moved the address bar to the bottom by default (with an option to restore the top). Thumb reach on tall phones; habit and Fitts in tension, resolved with a setting.
  • Pie and radial menusDon Hopkins and others, 1980s–; games
    Every item is equally close to the pointer and large in its angular direction. The geometry of Fitts's law, used directly.
For the solo creator

Add one CSS rule to your base styles and you fix half your Fitts problems for free: every icon button gets min-width:44px;min-height:44px and is centered in that box. Then make list rows clickable as a whole (a link that wraps the row). Those two changes cost an hour and improve every screen you will ever build.

Common mistakes

Text-only hit areas

The link or button wraps only its text, so "OK" is 20 px wide.

Pad buttons and make whole rows clickable. Check by outlining hit areas in dev tools.

Hover-to-reveal tiny controls

Hiding controls keeps the view clean.

Fine on desktop if there is a visible alternative; on touch there is no hover, so give a full-size control.

Edge with a gap

A design margin puts the toolbar 4 px from the top.

Let the hit area extend to the edge even if the visual stays inset.

Check yourself

In your mobile reading app, people often want to go "back to library" while holding the phone in one hand. The back button is a 28 px icon in the top-left. Which change helps most?

Exercise 13.1 40 minutes · on your own product

Hit-area audit

  1. In browser dev tools, add a temporary outline to all button, a, [role=button] to see hit areas.
  2. List every target under 44 × 44 px and every destructive target within 8 px of a frequent one.
  3. On mobile, screenshot your main screen and overlay a thumb-zone sketch. Note primary actions in the hard zone.
  4. Fix the three worst offenders.
You're done when: you have an outlined screenshot, a list of offenders, and three fixes shipped.
BeginnerCompetentStrong
Offenders listed.Three fixed, including one thumb-zone move.A global minimum hit-area rule added to your CSS, with no regressions.
14

Time: 0.1, 1 and 10 seconds, and the 400 ms threshold

Taught by Robert B. Miller, with Jakob Nielsen, Walter Doherty and Ahrvind Thadani

Below 0.1 s a response feels instant. Up to 1 s the user's flow of thought survives. Around 10 s, attention leaves. Your job is to keep real latency low and, where you cannot, to make waiting feel short and understood.

In 1968, Robert B. Miller at IBM published "Response time in man-computer conversational transactions", estimating how long people tolerate different kinds of waits. Jakob Nielsen distilled it in Usability Engineering (1993) into three limits that have survived every hardware generation because they are about people, not machines:

0.1 s 1 s 10 s 0.4 s Doherty Instant feels like directmanipulation Noticeable delay thought survives; show a subtle busy state Attention leaves show progress, allow other work,notify when done Not to scale (log-ish).
The three limits, plus Doherty. After Miller (1968) and Nielsen (1993); 0.4 s from Doherty and Thadani (1982).
  • 0.1 second: the limit for feeling that the system reacts instantly, as if you are manipulating the object directly. Typing, dragging, toggles, hover states must be here.
  • 1 second: the limit for the user's flow of thought to stay uninterrupted. They notice the delay but do not lose the thread. No special feedback strictly needed, though a light busy indicator after ~300–500 ms helps.
  • 10 seconds: the limit for keeping attention on the dialogue. Beyond it, people start doing other things, so show percent-done progress, let them work elsewhere, and tell them when it finishes.

The Doherty threshold

In 1982 Walter Doherty and Ahrvind Thadani at IBM published "The Economic Value of Rapid Response Time", reporting that when computer response time dropped below about 400 ms, user productivity rose sharply, as people and computer settled into a fast conversational rhythm. Be honest about the source: it is an industry paper from the mainframe era, measuring programmers' transactions, not a modern controlled experiment. The precise 400 ms number should not be treated as a law. The direction it points has been confirmed many times since: faster responses keep people engaged and productive, and every extra few hundred milliseconds on a frequent action adds up.

Lab: feel the delay
Press Save note.
Try 300 ms, 1,500 ms and 5,000 ms with each feedback mode. With no feedback, even 1.5 s feels broken and you will want to press again. An instant pressed state makes short waits acceptable; a spinner that appears only after 400 ms avoids flicker on fast saves; optimistic UI makes the wait vanish (but needs a plan for failure).

Perceived speed

When you cannot make it faster, you can still make it feel faster and more trustworthy:

  1. Acknowledge within 0.1 s. The button visibly presses, the row highlights. This is the most important rule; it tells people their action registered.
  2. Delay the spinner. Show busy indicators only if the wait passes about 300–500 ms, so fast actions do not flash.
  3. Optimistic updates. Show the result immediately and sync in the background, with a clear and recoverable failure state.
  4. Skeletons and progressive loading for content screens, so structure appears before data.
  5. Determinate progress for long tasks: a bar that moves steadily feels shorter than a spinner. Tell people what is happening ("Importing 1,240 notes").
  6. Let people leave. Above 10 s, run it in the background and notify on completion.

The craft of loading motion, skeletons and timing curves is in Motion & Feel.

Don't
Clicked Save. Nothing changes for 2 s.
Save
Silence. People click again, creating duplicates.
Better
Pressed state at once, "Saving…" after 400 ms.
Saving…
Acknowledged. The user knows it is working and the button is disabled.
Do
Shown as saved instantly; syncs quietly.
✓ Saved · syncing
Optimistic. Zero perceived wait; failures appear inline with retry.

Parkinson's law and time limits

C. Northcote Parkinson's 1955 essay in The Economist opened: "Work expands so as to fill the time available for its completion." It was satire about bureaucracy, not science. As a design heuristic it suggests that people take as long as a task seems to allow: an open-ended form invites over-thinking, while a clear, small scope ("Add a title, you can change it later") gets people moving. Use it gently: real time limits (countdowns, expiring offers) add stress and are a common dark pattern.

Do

  • Keep direct manipulation (typing, dragging, toggling) under 100 ms.
  • Acknowledge every action instantly, even if the work takes longer.
  • Show determinate progress and let people continue working for anything over ~10 s.
  • Set a performance budget for your three most frequent actions.

Don't

  • Show a spinner that flashes for 80 ms on fast connections.
  • Block the whole screen with a modal spinner for a background save.
  • Use an endless spinner for a task that takes minutes.
  • Add fake countdowns to create urgency.

In the wild

  • LinearLinear, 2019–
    Built around a local-first sync engine so most actions update the UI instantly and sync afterwards. Speed is a core part of its identity. Latency is a design decision made in the architecture.
  • Instagram uploadsInstagram
    Has been widely reported to start uploading photos in the background while you are still writing the caption, so "Share" feels instant. Do work before it is asked for.
  • macOS Finder copyApple
    Long copies show a determinate progress bar with time remaining in a separate, non-blocking window. Above 10 s, let people get on with other things.
For the solo creator

You test on a fast machine with a local server, so everything feels instant to you. Use your browser's network throttling ("Fast 3G" or "Slow 4G") and a CPU slowdown of 4× for one hour a week. Then write a tiny budget in your README: "Typing < 50 ms, save acknowledged < 100 ms, open document < 1 s on Slow 4G." A budget you can check is worth more than a vague wish to be fast.

Common mistakes

Optimistic UI without failure design

It feels great until the network fails and changes vanish silently.

Keep pending changes visible, retry automatically, and show a calm inline error with a manual retry.

Spinner flicker

The spinner appears on every request.

Delay it by ~400 ms and, once shown, keep it at least ~500 ms to avoid a flash.

Check yourself

Exporting a large library from your app takes about 40 seconds. Right now a modal spinner blocks the app until it finishes. What is the best design?

Exercise 14.1 45 minutes · on your own product

A latency budget

  1. List your 5 most frequent actions.
  2. Measure each with the network throttled to Slow 4G (use the Performance panel or simple timestamps).
  3. Classify each as under 0.1 s, under 1 s, under 10 s, or over.
  4. For each action over its target, choose: make faster, acknowledge instantly, go optimistic, or move to background.
  5. Write the budget into your README and fix the worst one.
You're done when: you have a measured table, a written budget and one action moved into a better band.
BeginnerCompetentStrong
Actions timed.Budget written and one action improved.A simple automated check (a test or a performance mark) keeps the budget from regressing.
15

Fast and slow: satisficing and the active user

Taught by Daniel Kahneman, with Amos Tversky, Herbert Simon, Steve Krug, John Carroll and Mary Beth Rosson

People mostly run on a fast, automatic mode of thinking and switch to slow, deliberate thought only when they must. They pick the first option that seems good enough, and they would rather start doing than read instructions. Design for that person, not for an ideal careful one.

System 1 and System 2

In Thinking, Fast and Slow (2011), Daniel Kahneman popularized a distinction from psychologists Keith Stanovich and Richard West: System 1 is fast, automatic, effortless and associative (reading a familiar word, recognizing a face, knowing that 2 + 2 = 4). System 2 is slow, effortful, deliberate and limited (computing 17 × 24, comparing two insurance plans). System 1 is always on and generates impressions; System 2 is lazy and only steps in when something feels wrong or hard.

Kahneman described these as useful fictions, characters in a story about the mind, not brain regions. The book also included some priming studies that later failed to replicate, which Kahneman publicly acknowledged. The core two-mode idea, and the heuristics and biases research with Amos Tversky, are on much firmer ground.

System 1fast, automatic Recognizes the blue button Reads "Delete" as danger Clicks the obvious default Judges trust by looks Most UI use happens here. Design for clear signals. System 2slow, effortful Compares two pricing plans Reads the export settings Debugs a failed sync Checks an unfamiliar warning Expensive and rare. Spend it only where it matters.
Two modes, one budget. Good design lets System 1 handle routine work and saves System 2 for decisions that deserve it. Friction is a tool: a little of it (typing a project name to delete it) wakes System 2 for dangerous actions.

Satisficing: good enough wins

Herbert Simon, who won the 1978 Nobel Prize in economics, coined "satisficing" (satisfy + suffice) in 1956: real decision-makers with limited time and information do not optimize; they pick the first option that meets their threshold. Steve Krug turned this into one of the best-known observations in web usability in Don't Make Me Think (2000): users do not read pages and choose the best link; they scan, pick the first reasonable option, and if it is wrong, press Back. Guessing is cheap and usually works, so it is rational.

Design consequence: the first plausible thing people see will be clicked. Make it the right thing, and make recovery (Back, Undo) cheap when it is not.

The paradox of the active user

John Carroll and Mary Beth Rosson (1987) studied people learning office software and found that they skipped manuals and tutorials to start doing real work immediately, even when reading first would have saved time. They called it a paradox: people would be more productive if they invested in learning, but their motivation to get something done right now wins. They also tend to stick with the methods they first learned, even inefficient ones ("production bias" and "assimilation bias").

Don't
Welcome! Swipe tolearn 12 features Skip › (what everyone taps)
Front-loaded learning. Active users skip it; those who read it forget it before they need it.
Do
Untitled Start writing… Tip: type # for a heading. Shown after your first paragraph. Got it
Do first, learn in context. The product opens ready for real work; hints appear at the moment they are useful, once.

Do

  • Make the first plausible option the right one for most people.
  • Let people do real work in the first minute; teach in context.
  • Make wrong guesses cheap with Back and Undo everywhere.
  • Add deliberate friction only to rare, dangerous actions, to wake System 2.

Don't

  • Rely on people reading instructions before acting.
  • Put a tutorial carousel between install and the first useful action.
  • Present a careful comparison where a sensible default would do.
  • Use friction everywhere; it trains people to click through.

In the wild

  • GitHub "delete repository"GitHub
    Asks you to type the repository's name to confirm. Deliberate friction that forces System 2 for one rare, destructive action.
  • Apple Notes, iA WriterApple; Information Architects
    Open straight into a blank document ready for typing. The active user gets to work instantly; there is nothing to learn first.
  • Figma's interactive file onboardingFigma
    Has used playground files where you learn tools by doing small tasks rather than reading. Learning by doing matches the active user.

Common mistakes

Designing for the careful reader

You read every word of your own UI, so you assume others do.

Assume only headings, button labels and the first words are read. Test by covering everything else.

Confirmations for routine actions

Friction feels safe.

Routine actions get undo; only rare, irreversible ones get friction.

Check yourself

Your new users must choose between "Local vault" and "Cloud vault" on the first screen, with a paragraph explaining the trade-offs. Most pick at random and some regret it. What does this chapter suggest?

Exercise 15.1 40 minutes · on your own product

The first-minute rewrite

  1. Install your product fresh (or use a clean account). Time how long until you can do one piece of real work.
  2. List every screen, choice and instruction before that point.
  3. For each: delete it, defer it until it is relevant, or replace it with a default.
  4. Aim for real work within 30 seconds of first launch.
You're done when: you have a before/after list of first-run steps and a measured time-to-first-real-work.
BeginnerCompetentStrong
Steps listed and timed.Half the steps removed or deferred.Real work within 30 s, with one contextual hint replacing the tutorial.
16

Choices people make: defaults, anchors, frames and losses

Taught by Amos Tversky and Daniel Kahneman, with Eric Johnson, Daniel Goldstein, Sheena Iyengar and Richard Thaler

How you present a choice changes what people choose: the default, the first number they see, the wording, and whether outcomes look like gains or losses. You cannot design a neutral choice, so design an honest one.

Richard Thaler and Cass Sunstein called this "choice architecture" in Nudge (2008): whoever designs the form shapes the decision. As the designer of your product, you are a choice architect whether you like it or not. This chapter covers the effects with the best evidence, plus one famous one with shaky evidence.

Defaults and status quo bias

William Samuelson and Richard Zeckhauser (1988) showed that people disproportionately stick with the current state of affairs. Eric Johnson and Daniel Goldstein's 2003 paper "Do Defaults Save Lives?" compared organ-donor consent across European countries: in countries where people were donors unless they opted out, effective consent rates were close to 100%; in countries requiring people to opt in, they were far lower (Germany around 12%, against Austria's near-universal rate). Same people, same values, different default.

Defaults win for three reasons: they take no effort (System 1), they look like a recommendation ("the designer chose this for a reason"), and changing them feels like taking a risk you could regret. For software, this means your defaults are the product for most people. Most users never open settings.

Same choice, different default (schematic, after Johnson & Goldstein 2003) Opt-out countries close to 100% Opt-in countries far lower (e.g. Germany ≈ 12%) Effective consent to organ donation. Defaults are decisions you make for most of your users.
The most powerful setting is the one nobody changes. Choose defaults that serve the user's interest, and make them easy to change.

Anchoring

In Tversky and Kahneman's 1974 paper "Judgment under Uncertainty: Heuristics and Biases", people spun a wheel of fortune rigged to land on 10 or 65, then estimated the percentage of African countries in the UN. Those who saw 65 gave much higher estimates. An arbitrary first number pulls later judgments toward it. In software: the first price people see sets their sense of what is expensive, the first suggested value in a field (a tip, a donation amount, a goal) pulls choices toward it, and the "was ₹ 2,999" next to a sale price works on anchoring. Honest uses: suggest sensible starting values. Dishonest uses: invented "original" prices.

Framing

Tversky and Kahneman's 1981 "Asian disease" problem described the same programs as "200 people will be saved" or "400 people will die" (out of 600). People preferred the sure option in the gain frame and the gamble in the loss frame. Same facts, different choice. In interfaces, "95% uptime" and "down 18 days a year" describe the same thing; "Free for 14 days" and "₹ 499 charged on 15 March" describe the same trial. Honest framing gives people the frame that helps them decide well, usually both numbers.

Loss aversion

Prospect theory (Kahneman and Tversky, 1979) found that losses feel roughly twice as heavy as equivalent gains. Some researchers (Gal and Rucker, 2018) argue the effect is smaller and more context-dependent than usually claimed, but loss-framed messages do reliably catch attention. This is why "You'll lose your 120-day streak" is so powerful, and why it is so easy to abuse. Use loss framing to warn about real losses (unsaved work, data deletion), not to manufacture anxiety.

Choice overload: the jam study and what came after

Sheena Iyengar and Mark Lepper's 2000 paper described a tasting booth in a California supermarket with either 24 or 6 jams. More people stopped at the large display, but of those who stopped, about 30% bought a jar when there were 6 options, against about 3% with 24. It became one of the most cited findings in design.

Then the replications came. Benjamin Scheibehenne, Rainer Greifeneder and Peter Todd's 2010 meta-analysis of 50 experiments found an average choice-overload effect of virtually zero, with large variation between studies. Alexander Chernev and colleagues' 2015 meta-analysis found the effect does appear, but reliably only under certain conditions: when the choice set is complex, the decision task is difficult, people are unsure of their preferences, or they want to minimize effort. So the honest lesson is not "fewer options sell more". It is: make options easy to compare, help people who do not know what they want, and do not make a hard decision harder with clutter.

Don't
Pro plan ₹ 9,999 ₹ 2,499/yr Add priority support (+₹ 999) Upgrade No thanks, I don't care about my work
Defaults, anchors and loss framing used against the user. Pre-checked add-on, invented "original" price, shaming decline.
Do
Pro plan ₹ 2,499/yr or ₹ 249/month Priority support (+₹ 999), optional Upgrade Not now
Honest architecture. The real comparison (yearly vs monthly) as the anchor, opt-in add-on, neutral decline. Still persuasive, never deceptive.
Watch out

Every effect in this chapter is also the engine of a dark pattern: pre-ticked boxes (defaults), fake discounts (anchoring), "confirmshaming" (framing), streak guilt (loss aversion). The line is simple to state: are you helping people get what they want, or getting them to do what you want against their interest? Deep coverage in Honest & Calm.

Do

  • Choose every default as if it were the only setting most users will ever have.
  • Use privacy-protective and cost-protective defaults.
  • Show real reference numbers (monthly vs yearly) rather than invented ones.
  • Give both frames for important numbers ("₹ 249/month, billed ₹ 2,499 yearly").
  • Make options comparable: same attributes, same order, a clear recommendation.

Don't

  • Pre-check paid add-ons, marketing consent or data sharing.
  • Show fake "original" prices.
  • Shame people for declining.
  • Use loss framing for things that are not real losses.
  • Cite the jam study as proof that fewer options always sell more.

In the wild

  • App Tracking TransparencyApple, iOS 14.5, 2021
    Turned cross-app tracking from a buried default into an explicit, plain-worded choice per app. Changing a default and its framing changed behavior across an entire industry.
  • Retirement auto-enrollmentUK workplace pensions, from 2012
    Employees are enrolled by default and can opt out; participation rose sharply. The textbook case of a default in the user's own long-term interest.
  • Basecamp pricing37signals
    Has long used very few, simply described plans with flat pricing. Easy comparison removes the conditions under which choice overload appears.

Common mistakes

Defaults by accident

The default is whatever the database column defaulted to.

Review every default as a deliberate design decision; write down why it is the best for most users.

Overgeneralizing the jam study

It is a great story.

Look for the real conditions of overload in your case: are options hard to compare? Do people know what they want? Fix those.

Single-frame numbers

The flattering frame looks better.

For prices, renewals and risks, show the frame that will matter to the user later, too.

Check yourself

Your app has three plans. Conversion is low and users say "I'm not sure which one I need." What is the most evidence-based change?

Exercise 16.1 40 minutes · on your own product

Default and frame review

  1. List every default in your product (settings, form pre-fills, notification opt-ins, plan selection, sort orders).
  2. For each, write who benefits from it: the user, you, or both.
  3. Change any default that benefits only you.
  4. Rewrite your pricing or upgrade screen so every number has an honest frame and nothing is pre-checked.
You're done when: you have a default inventory with a "who benefits" column and at least one changed default.
BeginnerCompetentStrong
Defaults listed.Self-serving defaults changed; pricing frames rewritten.A written "choice architecture" principle in your product notes that you apply to every new screen.
17

Shaping the experience: peaks, ends, progress and beauty

Taught by Daniel Kahneman, with Ran Kivetz, Joseph Nunes, Xavier Drèze, Hedwig von Restorff and Masaaki Kurosu

People remember an experience by its most intense moment and its end, not its average. They speed up as a goal gets close, push harder when they feel they have a head start, notice the one thing that differs, and judge good-looking things as easier to use.

The peak-end rule

In a 1993 study by Kahneman, Fredrickson, Schreiber and Redelmeier, people held a hand in painfully cold water (14°C) for 60 seconds, and in another trial for 60 seconds followed by 30 more seconds at a slightly warmer, still unpleasant 15°C. Asked which to repeat, most chose the longer trial: more total pain, but a better ending. A 1996 study by Redelmeier and Kahneman of colonoscopy patients found that memories of the procedure tracked the worst moment and the final moments, not its length ("duration neglect").

For products: the remembered experience of your app is built from peaks (the best and the worst moments) and endings (how a task, session or subscription ends). A smooth hour can be remembered as awful because of one lost draft. A frustrating setup can be redeemed by a delightful first result.

goodbad peak: sync conflict lost a paragraph end: "Published" with a lovely preview Memory ≈ f(worst moment, final moment). The long calm middle barely counts.
Design the peaks and the ending. Remove the worst moments first (they dominate), then make endings of key flows feel complete and good.

Goal-gradient and endowed progress

Clark Hull observed in 1932 that rats in a maze ran faster as they got closer to food. Ran Kivetz, Oleg Urminsky and Yuhuang Zheng (2006) found the same in people: customers with a coffee-shop loyalty card bought coffee more often as they got closer to the free drink. Joseph Nunes and Xavier Drèze (2006) then gave car-wash customers loyalty cards needing 8 stamps, or cards needing 10 stamps with 2 already stamped. The task was identical (8 more washes), but 34% of the "head start" group completed it against 19% of the others. This is the endowed progress effect: progress that feels already begun motivates.

Card A: 8 stamps needed 19% completed Card B: 10 needed, 2 already stamped 34% completed Both cards require 8 more washes. Nunes & Drèze, 2006.
Same work, different feeling. The head start is honest only if it is real: an onboarding checklist that ticks "Created your account" is true; a fake 20% is not.

The isolation (von Restorff) effect

Hedwig von Restorff reported in 1933 that an item that differs from the others in a list is remembered better. It is the memory side of preattentive pop-out (chapter 4). Designers use it to highlight the recommended plan, the primary button, the one new item. It only works when one thing differs, and the effect is stronger for things that are also meaningful.

Don't
Basic₹ 0
Plus₹ 199
Pro₹ 499
Three identical cards
No isolation. Nothing stands out, so nothing is remembered, and undecided people have no guidance.
Do
Basic₹ 0
Plus · most people₹ 199
Pro₹ 499
One card isolated, with a reason
One difference, with meaning. The isolated plan is remembered and the label says why it is recommended.

The aesthetic-usability effect

Masaaki Kurosu and Kaori Kashimura (1995) asked people at Hitachi to rate 26 ATM interface layouts for beauty and for expected ease of use. The two ratings correlated strongly. Noam Tractinsky replicated it in Israel in 1997, finding the effect even stronger. Later work showed that attractive interfaces are judged more usable and that people tolerate small problems in them more. Two honest notes. First, perceived usability is not actual usability: beauty can hide problems from your testers. Second, the effect is about first impressions and goodwill; it does not rescue a product that fails at its job. Visual craft is covered in Visual Design.

Do

  • Find and remove the worst moments first (data loss, confusing errors).
  • End key flows with a clear, satisfying completion state.
  • Show real progress toward goals people chose, and credit steps already done.
  • Isolate one recommended option and say why.
  • Invest in visual craft, and test usability with tasks, not opinions.

Don't

  • Average your satisfaction data and ignore the worst incidents.
  • End a flow on a blank page or a raw redirect.
  • Fake progress (starting a bar at 20% for nothing).
  • Highlight several options "to be fair"; it cancels isolation.
  • Let a beautiful prototype stand in for a usability test.

In the wild

  • MailchimpIntuit Mailchimp
    After you send a campaign, the mascot's hand gives you a high five. Sending an email campaign is stressful; the ending is a small celebration. A designed positive end to an anxious task.
  • AsanaAsana
    Occasionally shows a celebratory creature flying across the screen when you complete a task (it can be turned off). A playful peak, made optional for those who find it distracting.
  • LinkedIn profile strengthLinkedIn
    A meter shows how complete your profile is and suggests the next step. Goal-gradient and endowed progress in one widget; useful when the goal is the user's, nagging when it is not.

Common mistakes

Polishing the middle

Average flows get the attention because they are where most time is spent.

Rank problems by peak severity, not by frequency alone; one lost document outweighs a hundred slightly slow screens.

Celebrations that interrupt

Delight is added to every action.

Celebrate rare milestones, keep it short, and let people turn it off.

Endings that just stop

After submit, the code redirects to the home screen.

Design a completion state: what happened, what is next, and a moment of closure.

Check yourself

Your app's satisfaction is fine on average, but reviews often mention "it lost my work once and I never trusted it again". You have one week. Where does the peak-end rule say to spend it?

Exercise 17.1 45 minutes · on your own product

Draw the experience curve

  1. Pick one complete journey (first launch to first success, or a weekly routine).
  2. Draw it as a curve like the one above: mark every moment that feels better or worse than neutral.
  3. Circle the lowest point and the end.
  4. Write one fix for the lowest point and one improvement for the ending. Build the first.
You're done when: you have a drawn experience curve with the worst moment fixed and an ending redesigned.
BeginnerCompetentStrong
Curve drawn.Worst moment fixed.Ending redesigned too, and checked with someone who used the old version.
18

Laws of complexity and convention: Tesler, Postel, Jakob, Occam, Pareto

Taught by Larry Tesler, with Jon Postel, Jakob Nielsen, William of Ockham and Joseph Juran

Every task has complexity that cannot be removed, only moved, so move it into the software. Accept messy input and produce clean output. Follow the conventions people learned elsewhere. Prefer the simplest design that works, and focus on the few features that do most of the work.

These five are rules of thumb, not experimental findings. They earn their place because each names a trade-off that designers face weekly.

Tesler's law: conservation of complexity

Larry Tesler (who worked at Xerox PARC and Apple, and is credited with cut, copy and paste as we know them) argued in the mid-1980s that every application has an inherent amount of complexity that cannot be removed. The only question is who deals with it: the user or the developer. He argued that an engineer should spend an extra week to save each of millions of users a minute a day.

Same task: add an event "Lunch with Anu tomorrow 1pm" User carries it Title fieldDate picker (find tomorrow)Time picker (1:00 PM)Duration dropdownInvite field Software carries it Lunch with Anu tomorrow 1pm Parsed: tomorrow, 13:00–14:00 Invite Anu Sharma? (parser, contacts, defaults: your work)
The complexity did not disappear; it moved into code. Natural-language entry in calendar apps like Fantastical is the classic example. The structured form remains for edits.

Postel's law: liberal in, conservative out

Jon Postel wrote the robustness principle into early internet protocol specifications (RFC 760 in 1980 and RFC 793, TCP, in 1981): "be conservative in what you do, be liberal in what you accept from others." For interfaces: accept phone numbers with or without spaces, dates in several formats, pasted text with stray whitespace, emails with capital letters; then store and display them in one clean format. A caution from the protocol world: being too liberal can hide errors and create security issues, so be liberal about format, strict about meaning (do not guess when the input is genuinely ambiguous).

Don't
Phone
+91 98765 43210
Invalid format. Use 10 digits without spaces.
Strict in. The input is perfectly clear; the validator punishes the user for formatting it the way it is printed everywhere.
Do
Phone
+91 98765 43210
✓ Saved as +91 98765 43210
Liberal in, clean out. Spaces, dashes and the country code are all accepted and normalized.

Jakob's law: people spend most of their time elsewhere

Jakob Nielsen observed that users spend most of their time on other sites and apps, so they expect yours to work the same way. In perception terms (chapter 1), conventions are predictions the brain already has. Breaking them has a cost every time, and must buy something worth more. Conventions to keep unless you have a strong reason: logo links home, search is a magnifying glass, the shopping cart is top-right on the web, swipe-back on iOS, Cmd/Ctrl+Z undoes, Esc closes, a gear means settings. Platform conventions are covered in Systems & Platforms.

Occam's razor and Pareto

Occam's razor, from the 14th-century philosopher William of Ockham, says not to multiply entities beyond necessity: among designs that solve the problem equally, prefer the one with fewest parts. Each extra element, setting or mode adds a little perceptual, memory and decision load from every chapter of this guide. The Pareto principle, named by quality expert Joseph Juran after the economist Vilfredo Pareto's observation of income distribution, says that roughly 80% of effects come from 20% of causes. In products it is often true that a small set of features accounts for most use, and a few bugs cause most crashes. Treat the 80/20 as a shape, not a precise ratio.

LawKindUse it to ask
TeslerRule of thumb"Who is carrying this complexity, and can my code carry it instead?"
PostelEngineering principle"Am I rejecting input whose meaning is clear?"
JakobObservation"Is breaking this convention worth the cost every user pays?"
OccamPhilosophical principle"Could this work with one fewer part?"
ParetoStatistical pattern"What are the few things that matter most here?"

Do

  • Spend engineering time to remove user effort on frequent tasks.
  • Accept common formats and normalize them.
  • Follow platform and web conventions for controls, gestures and shortcuts.
  • Remove features and settings that few people use and that add load for everyone.
  • Find your 20%: the features most use comes from, and make them excellent.

Don't

  • Push complexity onto users because it is easier to build.
  • Guess when input is genuinely ambiguous (03/04 could be March or April).
  • Reinvent standard controls for novelty.
  • Treat 80/20 as an exact law, or as a reason to neglect accessibility needs of the "20%".

In the wild

  • FantasticalFlexibits, 2011–
    Known for natural-language event entry that shows the parsed result live as you type. Tesler's law: the parser carries the complexity, and the live preview keeps the user in control.
  • Stripe API and CheckoutStripe
    Absorbs card networks, 3-D Secure, local payment methods and tax rules behind a small surface. A business built on moving complexity from users into software.
  • Google SheetsGoogle
    Follows Excel's formulas, shortcuts and layout closely. Jakob's law as strategy: switching costs fall when nothing needs relearning.
For the solo creator

Tesler's law is uncomfortable for a solo builder, because the user's minute saved is your week spent. Use Pareto to decide where: carry complexity in code for the 20% of tasks people do daily, and accept a plainer form for rare ones. And Occam's razor is your friend twice: every feature you do not build is a feature you never have to maintain, document or support.

Common mistakes

Settings as a complexity dump

When you cannot decide, you add an option.

Decide. Choose a good default; add a setting only when users with real needs disagree.

Novel controls

Custom dropdowns and gestures feel distinctive.

Be distinctive in content, tone and quality; use standard controls.

Over-liberal parsing

You want to accept everything.

Show how the input was interpreted, and ask when it is ambiguous.

Check yourself

Your expense app asks users to pick a currency, then a category, then type the amount, then pick a date for each expense. Most expenses are in ₹, today, and in the same three categories. Which law suggests the clearest improvement?

Exercise 18.1 50 minutes · on your own product

Move one burden into code

  1. Find the most frequent form or input in your product.
  2. List every field and every validation rule.
  3. For each field: can it be defaulted, inferred, remembered or parsed? For each rule: is it rejecting clear input?
  4. Implement the two biggest wins.
You're done when: the form needs fewer interactions for the common case and accepts at least two formats it used to reject.
BeginnerCompetentStrong
Fields and rules listed.Two improvements shipped.Common case measured before and after (clicks or seconds), with an ambiguity check for parsed input.
Part four recap: connect the ideas

You are designing the "new task" action in a to-do app. Which combination best applies Part four?

Part five

Motivation and emotion: why people come back, and how it feels

Perception, attention and memory explain whether people can use your product. Motivation and emotion explain whether they want to, and what they feel and remember afterwards. This is also where the psychology is most often abused, so each chapter ends at the line between helping and manipulating.

19

Motivation: autonomy, competence, relatedness, and B = MAP

Taught by Edward Deci and Richard Ryan, with BJ Fogg and Mihaly Csikszentmihalyi

Lasting motivation comes from feeling in control, getting better, and being connected to others. A behavior happens when motivation, ability and a prompt meet at the same moment. Make the right action easy and well-timed; do not try to pump motivation with tricks.

Self-determination theory

Edward Deci and Richard Ryan developed self-determination theory from the 1970s onward (major statements in 1985 and 2000). It is one of the most researched theories of human motivation. It holds that people have three basic psychological needs, and that activities which satisfy them are pursued for their own sake (intrinsic motivation), while activities that thwart them feel like chores. A famous early finding by Deci (1971) was that paying people for an activity they already enjoyed could reduce their interest in it afterwards: external rewards can crowd out intrinsic motivation when they feel controlling.

Autonomy "I chose this" Competence "I'm getting better" Relatedness "I'm connected" intrinsic motivation
Three needs. After Deci and Ryan. A product people love usually satisfies at least two.
NeedSupports itThwarts it
AutonomyReal choices, customization, easy export, no lock-in, explaining whyForced flows, nagging, hidden settings, guilt, punishing breaks
CompetenceClear feedback, visible progress, mastery paths, shortcuts, good errorsUnclear state, failure without explanation, condescending hand-holding
RelatednessSharing, collaboration, acknowledgement from real people, a human voiceFake social proof, leaderboards that shame, robotic tone

Fogg Behavior Model: B = MAP

BJ Fogg at Stanford proposed in 2009 that a behavior (B) happens when three elements converge at the same moment: Motivation (M), Ability (A), and a Prompt (P; he originally called it a "trigger"). If any is missing, the behavior does not happen. Motivation and ability trade off: a very easy behavior needs little motivation, a hard one needs a lot. The prompt only works when the person is above the "action line". His 2019 book Tiny Habits applies it to personal habit building: make the behavior tiny, anchor it to an existing routine, celebrate.

Motivation hard to doeasy to do Ability action line prompt workseasy + enough motivation prompt failstoo hard for current motivation the designer's lever: make it easier
Ability is the lever you control. Motivation fluctuates and is hard to raise ethically. Making the behavior easier moves the dot right, above the line. After Fogg (2009).

The ethics of behavior design

The same model that helps someone build a reading habit can be used to keep people scrolling at 2 a.m. Several products built on persuasive design have been criticized for exactly that, and some of their designers have since spoken publicly against attention-maximizing design. A practical test for your product:

  • Whose goal is it? Prompts that help people do what they set out to do are help. Prompts that create new wants on your schedule are manipulation.
  • Would they thank you later? Imagine the user looking back at a month of your prompts. Would they say "that helped" or "that hooked me"?
  • Can they turn it off easily? If not, you do not believe they would choose it.

This is developed fully in Honest & Calm.

Do

  • Make the desired behavior tiny and easy (the first step under 10 seconds).
  • Let users set their own prompts (time, frequency, channel).
  • Give clear feedback on growing skill (competence).
  • Make it easy to leave, export and pause (autonomy).
  • Connect people to real people where it helps (relatedness).

Don't

  • Try to manufacture motivation with points, badges and pressure.
  • Punish breaks with lost streaks and guilt.
  • Send prompts when the user cannot act (above the action line or not).
  • Show fake social proof ("27 people are viewing this").

In the wild

  • DuolingoDuolingo, 2012–
    Tiny lessons (ability), daily reminders (prompt), visible progress (competence), and streaks. It added "streak freezes" so a missed day need not erase progress. A strong behavior-design product, and a live debate on where streak pressure stops being helpful.
  • StravaStrava, 2009–
    Kudos and clubs connect people around exercise they already chose to do. Relatedness that reinforces an intrinsic goal.
  • ObsidianObsidian, 2020–
    Notes are plain Markdown files on your own disk, and almost everything is configurable. Deep autonomy as a core value attracts deeply loyal users.
For the solo creator

You cannot out-gamify companies with behavior-science teams, and you should not try. Your strengths are autonomy (no lock-in, honest export), competence (a tool that makes people better at something), and relatedness (you, a real person, answering their emails). Those three are SDT's needs, and they are the reasons people love small, independent software.

Common mistakes

Gamifying intrinsic activities

Points feel like engagement.

If people already want to do it (write, read, learn), reward with feedback on their actual progress, not arbitrary points that can crowd out interest.

Prompting the unable

The reminder fires at 9 a.m. for everyone.

Let users pick the time, and make the action doable from the prompt itself.

Check yourself

Your journaling app sends a daily 9 p.m. reminder. Many users ignore it; some uninstall. Using B = MAP and SDT, what is the best change?

Exercise 19.1 40 minutes · on your own product

B = MAP and SDT audit

  1. Pick the one behavior that defines success for your users (write a note, read an article, log a workout).
  2. Map it: what prompts it? How many steps and seconds does it take (ability)? Where does motivation come from?
  3. Reduce the steps for the first action to the minimum.
  4. Score your product 1–5 on autonomy, competence and relatedness, with one improvement for the lowest.
You're done when: you have a B = MAP map of the key behavior, a shorter first action, and an SDT scorecard.
BeginnerCompetentStrong
Behavior mapped.Ability improved measurably (fewer steps).SDT weakest need improved, and every prompt passes the "would they thank you" test.
20

Emotion: visceral, behavioral, reflective, and trust

Taught by Don Norman, with Noriaki Kano, BJ Fogg and Aarron Walter

People respond to a product on three levels at once: an instant gut reaction to how it looks, a feeling from how it works in use, and a considered judgment of what it means to them. Delight is real but fragile; trust is slow to build and quick to lose.

Norman's three levels

In Emotional Design (2004), Don Norman, who had been known for championing usability over beauty, argued that attractive things work better, and offered a model of three levels of processing:

Reflective: what it means identity, story, pride, memory · days to years Behavioral: how it works control, efficiency, feel in use · seconds to hours Visceral: how it looks and feels instant, automatic, pre-conscious · milliseconds After Norman, Emotional Design (2004)
Three timescales, one product. Visceral wins the first glance, behavioral wins the first week, reflective wins loyalty and recommendations.
  • Visceral: the instant, pre-conscious reaction to appearance, sound and feel. It is where the aesthetic-usability effect lives (chapter 17), and where your app icon, first screen and typography do their work. Studies by Gitte Lindgaard and colleagues (2006) found people form reliable impressions of web pages' visual appeal in as little as 50 milliseconds.
  • Behavioral: the pleasure and frustration of use: control, speed, predictability, the feel of scrolling and typing. This is most of this guide.
  • Reflective: conscious thought about the product: what owning or using it says about you, the story you tell others, memories of using it. It is shaped by brand, values and peak-end memories.

Delight versus satisfaction: the Kano pointer

Noriaki Kano's model (1984) sorts features by how they affect satisfaction. Basic features cause dissatisfaction when missing but no delight when present (sync that works, undo). Performance features increase satisfaction roughly in proportion (faster search). Delighters are unexpected and cause outsized pleasure, but people do not miss them when absent. Over time, delighters decay into expectations: what delighted in 2010 is basic in 2026. The practical rule: delight sits on top of a working foundation, never instead of it. Aarron Walter's Designing for Emotion (2011) expressed this as a hierarchy: functional, reliable, usable, then pleasurable. Kano is applied to prioritizing features in Problems Worth Solving.

delightedfrustrated absentfully present Performance Delighters Basics only noticed when missing
Delighters over a broken basic do not help. After Kano (1984). An animation that celebrates a save means nothing if saves sometimes fail.

Trust signals

Trust is a judgment about whether a product will act in your interest when you are not watching. The Stanford Web Credibility Project, led by BJ Fogg (2002), asked over 2,500 people to compare websites' credibility; the most frequently mentioned factor was the "design look" of the site. That is System 1 judging competence from polish. But the visual impression is only a first filter. Lasting trust comes from behavior over time:

SignalBuilds trustErodes trust
Care and polishConsistent details, no broken states, good typographyMisaligned UI, lorem ipsum, broken images
TransparencyClear pricing, plain privacy terms, honest status pagesHidden fees, surprise renewals, vague data use
ControlUndo, export, easy cancellation, clear permissionsLock-in, cancellation mazes, permission grabs
ReliabilityNever losing data, predictable behavior, honest error messagesLost work, silent failures, "something went wrong"
A humanA named maker, real replies, a changelogNo contact, no history, fake testimonials
Don't
Oops! Something went wrong. OK
Cute at the worst moment. Playful tone at a negative peak reads as not caring. Did my note save? No one knows.
Do
Trip plan Saved on this device. Couldn't reach the server; will sync when you're online. Retry now
Calm, specific, in control. Says what is safe, what failed, what happens next. Trust built at the worst moment.

Do

  • Design the first screen and icon for a calm, confident visceral impression.
  • Get basics flawless before adding delighters.
  • Match tone to the moment: playful in success, plain and specific in failure.
  • Show your name, your pricing and your data practices plainly.
  • Keep delight brief, rare and optional.

Don't

  • Rely on a beautiful surface to cover unreliable behavior.
  • Use jokes and mascots in error and loss moments.
  • Fake trust signals (invented user counts, stock-photo testimonials).
  • Make cancellation harder than sign-up.

In the wild

  • Things 3Cultured Code, 2017
    Won an Apple Design Award; known for refined visuals (visceral), a smooth, predictable feel in use (behavioral) and a reputation for craft that users are proud to recommend (reflective). All three levels pulling the same way.
  • Stripe status and docsStripe
    Public status page, precise error codes, and detailed changelogs for API versions. Transparency and reliability as trust signals to developers.
  • Braun and Dieter RamsBraun, 1955–1995
    Products whose calm visual order (visceral) matched their honest function (behavioral) and became objects of pride (reflective). The physical template for calm software; see Breakdowns: Objects.

Common mistakes

Delight as a substitute for reliability

Delight is fun to build; reliability is not.

No delighter ships while a known data-loss or crash bug is open.

One tone everywhere

A brand voice guide says "playful".

Write a tone map: celebratory for success, neutral for routine, serious and specific for errors and money. See Words.

Ignoring the reflective level

Solo makers focus on features.

Write the one sentence a happy user would say about your product to a friend, and design toward it.

Check yourself

You have a week. Your app has a confetti animation on task completion, but sync occasionally duplicates tasks. Users rate it 3.4 stars. What does the Kano model suggest?

Exercise 20.1 45 minutes · on your own product

Three-level review and trust inventory

  1. Write one paragraph each on how your product performs at the visceral, behavioral and reflective levels. Be specific.
  2. Sort your features into Kano categories: basic, performance, delighter. Mark any basic that is unreliable.
  3. List your trust signals using the table above. Mark missing ones.
  4. Fix the most damaging gap (usually a basic or an error message).
You're done when: you have a three-level review, a Kano sort, a trust inventory and one fix shipped.
BeginnerCompetentStrong
Three levels described.Kano sort done; one basic fixed.Trust gaps closed (pricing, data practices, contact) and error tone rewritten for negative moments.
Part five recap: connect the ideas

Which design best combines motivation and emotion ideas with earlier parts for a habit-forming reading app that stays honest?

Part six

Reference: the laws in one place

A quick reference you can return to, with an honest evidence rating for each law, and a cognitive audit checklist to run on your own product.

21

The laws of UX: quick reference and audit

Compiled from the chapters above, with credit to Jon Yablonski's Laws of UX for popularizing the set

A law is useful only if you know what it predicts, how strong the evidence is, and what to do differently on Monday. This table gives all three.

Evidence ratings: Strong means decades of replicated lab or field results; Moderate means real effects whose size or conditions vary; Heuristic means a wise rule of thumb, not an experimental finding; Contested means the famous version has failed to replicate or is much narrower than claimed.

LawWhat it saysEvidenceDesign implicationExample
Gestalt groupingProximity, similarity, region and connection create perceived groupsStrongGroup with space first; regions sparinglyiOS Settings sections (ch. 2)
Figure-ground, closure, common fateThe brain builds layers, completes shapes, binds moving thingsStrongDim backdrops, peeking cards, move groups togetheriOS sheets (ch. 3)
Preattentive pop-outSingle-feature differences are found in parallel; conjunctions are searchedStrong (refined by guided search)Keep a quiet baseline; one or two pop-outs per screenUnread dot in Mail (ch. 4)
Change and inattentional blindnessUnattended changes and unexpected objects go unseenStrongUpdate in place; feedback at the locusInline validation (ch. 5)
Banner blindnessAd-like elements are ignoredStrong (eye-tracking)Never put key info in ad-shaped boxesRight-rail notices (ch. 6)
F and layer-cake scanningUnstructured text yields an F; headings yield a layer-cakeModerate to strong (eye-tracking)Meaningful headings, front-loaded wordsGOV.UK (ch. 7)
Z-patternSparse layouts read along a ZHeuristicComposition aid for hero sections onlyLanding pages (ch. 7)
FlowAbsorption needs clear goals, feedback, challenge matched to skillModerate to strongProtect focus; let challenge grow with skillKindle (ch. 8)
Interruption costInterruptions raise stress and delay resumptionModerate to strongBatch notifications; preserve placeiOS Notification Summary (ch. 8)
Working memory (Cowan)About 4 chunks held at onceStrongNever make people carry values between screensOTP autofill (ch. 9)
Miller's 7±2Span with rehearsal ≈ 7; famous misuse for menusStrong for span, misapplied to menusUse chunking; do not limit visible menus by itChunked IBAN (ch. 9)
Cognitive loadIntrinsic, extraneous (and germane) load share one capacityStrong in instruction researchCut extraneous load ruthlesslyShort forms (ch. 9)
Recognition over recallRecognizing is easier than recallingStrongShow options, recents, previewsCommand palettes (ch. 10)
Mental modelsPeople act on their own theory of the systemStrong (as a framework)Teach the model through the system imageDropbox folder (ch. 10)
HabituationRepeated actions become automatic and location-boundStrongKeep frequent controls stable; prefer undo to confirmTab bar changes (ch. 11)
Serial positionFirst and last items are remembered bestStrongKey items at the start and endTab bar ends (ch. 11)
ZeigarnikUnfinished tasks remembered betterContested (resumption urge holds better)Show user-chosen unfinished work; no fake tasks"Continue draft" (ch. 11)
Hick's lawChoice time grows with log of equally likely optionsStrong but narrowWeight by likelihood, order lists, use defaultsExport menu (ch. 12)
Fitts's lawPointing time grows with distance/sizeStrongBig, close targets; edges; 44 pt minimumMac menu bar (ch. 13)
Response limits0.1 s instant, 1 s flow, 10 s attentionStrong as guidelinesAcknowledge in 0.1 s; progress above 10 sOptimistic UI (ch. 14)
Doherty thresholdProductivity rises below ~400 msModerate (old industry data)Treat 400 ms as a target for frequent actionsLocal-first apps (ch. 14)
Parkinson's lawWork expands to fill time availableHeuristic (satire)Scope tasks small and clear; avoid fake deadlines"Add a title, change later" (ch. 14)
System 1 / 2Fast automatic vs slow deliberate thinkingStrong as a framework; some priming claims failedClear signals for routine; friction only for dangerType-to-delete (ch. 15)
SatisficingPeople pick the first good-enough optionStrongFirst plausible option should be right; cheap BackKrug's scanning (ch. 15)
Paradox of the active userPeople skip learning to start doingStrong (observational)Real work in the first minute; teach in contextApps that open to a blank page (ch. 15)
Defaults / status quoPeople stick with the presetStrongChoose defaults in the user's interestPension auto-enrollment (ch. 16)
AnchoringFirst numbers pull later judgmentsStrongHonest reference prices and suggested valuesMonthly vs yearly (ch. 16)
FramingSame facts, different wording, different choiceStrongGive the frame that helps the decision; often bothTrial renewal dates (ch. 16)
Loss aversionLosses loom larger than gainsModerate (size debated)Warn about real losses onlyUnsaved changes (ch. 16)
Choice overloadToo many options reduce choosingContested; conditionalMake options comparable; recommend oneJam study (ch. 16)
Peak-end ruleMemory follows the peak and the endStrongRemove worst moments; design endingsMailchimp high five (ch. 17)
Goal-gradientEffort rises near the goalModerate to strongShow real progress toward chosen goalsCoffee card (ch. 17)
Endowed progressA head start increases completionModerateCredit real steps already doneCar wash card (ch. 17)
Von RestorffThe different item is rememberedStrongIsolate one recommended optionPricing card (ch. 17)
Aesthetic-usabilityBeautiful things are perceived as easierModerate to strong for perceptionInvest in craft; test with tasks, not opinionsATM study (ch. 17)
Tesler's lawComplexity is conserved; someone carries itHeuristicLet code carry it for frequent tasksNatural-language dates (ch. 18)
Postel's lawLiberal in, conservative outEngineering principleAccept formats; normalize; ask when ambiguousPhone fields (ch. 18)
Jakob's lawUsers expect your product to work like othersHeuristic, well supported by perceptionFollow conventions for controlsSheets copying Excel (ch. 18)
Occam's razorPrefer fewer partsHeuristicRemove what does not earn its placeEvery settings screen (ch. 18)
Pareto principleFew causes produce most effectsStatistical pattern, ratio variesMake the core 20% excellentFeature usage (ch. 18)
Self-determinationAutonomy, competence, relatedness drive intrinsic motivationStrongSupport all three; avoid controlling rewardsObsidian, Strava (ch. 19)
Fogg B = MAPBehavior needs motivation, ability and a prompt togetherModel (widely used, less formally tested)Make it easy; user-chosen promptsDuolingo (ch. 19)
Three levels of emotionVisceral, behavioral, reflectiveFrameworkDesign for all three timescalesThings 3 (ch. 20)
Kano modelBasics, performance, delightersFramework, widely usedBasics first, then delightSync before confetti (ch. 20)
Where each law acts in one interaction Perceive Attend Remember Decide Act Feel Gestaltpop-outcontrastaesthetic-usability locusbannerblindnessscanningflow ~4 chunksrecognitionmental modelsserial positionhabit Hickdefaultsanchoringframingsatisficing Fitts0.1 / 1 / 10 sDohertyTeslerPostel peak-endSDTthree levelsKanotrust Each click is a loop through all six. A failure at any step feels to the user like "this app is confusing"; your job is to find which step failed.
Diagnose by stage. When something goes wrong in a test, ask: did they not see it, not notice it, forget it, choose wrong, fail to hit it, or not want to?

How to use this table without becoming a law-quoter

  1. Start from an observed problem, not a law. "People miss the error" comes first; "change blindness" is the explanation that suggests fixes.
  2. Check the evidence column before betting a design on a law. Heuristics are prompts for thinking, not proofs.
  3. Expect laws to conflict. Fitts wants big buttons; Occam wants fewer parts; Jakob wants convention; delight wants surprise. Your judgment weighs them for this user and task.
  4. Verify with people. A five-person test beats a citation. See Testing & Iteration.

Do

  • Use laws to explain and predict, then confirm with a test.
  • Name the stage (perceive, attend, remember, decide, act, feel) where a problem occurs.
  • Cite the evidence level when you justify a decision to yourself.

Don't

  • Decorate decisions with law names after the fact.
  • Treat heuristics and contested findings as physics.
  • Apply a law outside the conditions it was found in.

In the wild

  • Laws of UXJon Yablonski, website 2017, book 2020
    Popularized a curated set of psychology principles for designers with clear summaries. A great index; read the original studies behind the laws you rely on most.
  • Nielsen's 10 heuristicsJakob Nielsen, 1994
    Several heuristics (visibility of status, recognition over recall, error prevention) are the laws in this guide turned into review questions. Laws become useful as questions you ask of a screen.
  • Apple Human Interface GuidelinesApple
    Target sizes, feedback, consistency and platform conventions encode Fitts, response time and Jakob's law into concrete rules. Platform guidelines are applied psychology; learn the "why" so you know when they bend.

Common mistakes

Law-washing

Naming a law makes a preference sound scientific.

State the observed problem and the evidence level; let the test decide.

Single-law thinking

One law is memorable.

Run the six-stage diagnosis; most real problems involve two or three stages.

Check yourself

In a test, a user says "I didn't know I could drag notes into folders". At which stage did it fail, and what is the likely fix?

Exercise 21.1 90 minutes · on your own product

The full cognitive audit

  1. Pick your product's core flow, start to finish.
  2. Run the checklist below on it, honestly, one item at a time.
  3. For every unchecked item, write the screen, the stage and a proposed fix.
  4. Rank fixes by severity (worst peak first) and effort. Do the top three this week.
You're done when: the checklist is complete, you have a ranked fix list, and the top three are shipped.
BeginnerCompetentStrong
Checklist run.Fixes ranked and three shipped.Re-run a month later shows improvement, and you added your own items to the list.

Checklist: cognitive audit of your product

Perception
Attention
Memory
Decision and action
Motivation and emotion

Wrap-up

You now have a working model of the person on the other side of the screen: a visual system that groups and predicts, an attention that holds one thing, a memory that holds about four, a hand that obeys Fitts, a decision-maker who satisfices and follows defaults, and a human who wants autonomy, competence and connection and remembers peaks and endings. Every later guide builds on this. Typography is perception applied to reading; motion is common fate and response time; words are recognition and framing; ethics is what you do with all of it.

Ten things to remember

  1. Perception is prediction. Conventions and clear edges let people's brains guess right.
  2. Group with space first, regions second, lines last. Spacing is meaning.
  3. Pop-out works only on a quiet background. Spend salience on one or two things.
  4. If a change is not at the locus of attention, assume it was not seen.
  5. People scan for anchors; give them meaningful headings and front-loaded words.
  6. Working memory holds about four chunks. Never make people carry information between screens.
  7. Habits are tied to position. Keep frequent controls where they are; prefer undo to confirmation.
  8. Bigger and closer is faster. Acknowledge every action within 0.1 s.
  9. Defaults, anchors and frames shape choices. Use them for the user, never against them.
  10. Remove the worst moment, design the ending, and build on autonomy, competence and relatedness.

Self-assessment: I can…

Practice assignment for the next two weeks

About 30 minutes a day. Each day produces one small artefact in a single "Mind notes" document.

DayPracticeArtefact
1Blur and grayscale pass on your three main screens (Ex. 1.1)Annotated screenshots
2Draw perceived groups vs intended groups (Ex. 2.1)Grouping map and one spacing fix
3Gestalt spotting in three daily apps (Ex. 3.1)Six annotated screenshots
4Salience budget (Ex. 4.1) and silent-change hunt (Ex. 5.1)Ranked salience list, side-effect table
5Locus map (Ex. 6.1) and headings-only test (Ex. 7.1)Annotated flow strip, rewritten headings
6Notification triage (Ex. 8.1)Triage table, one notification removed
7Rest and reflect: which three ideas changed how you see your product?Half-page reflection
8Memory-load inventory (Ex. 9.1) and habit map (Ex. 11.1)Load table, stability contract
9Draw a friend's mental model (Ex. 10.1)Two drawings and one system-image fix
10Weight the choices (Ex. 12.1) and hit-area audit (Ex. 13.1)Redesigned menu, three target fixes
11Latency budget (Ex. 14.1)Budget in README, one action improved
12First-minute rewrite (Ex. 15.1) and default review (Ex. 16.1)Time-to-first-work, default inventory
13Experience curve (Ex. 17.1) and move a burden into code (Ex. 18.1)Curve with worst moment fixed
14Full cognitive audit (Ex. 21.1), plus SDT and three-level review (Ex. 19.1, 20.1)Completed checklist and ranked fix list

Reflection prompt

Think of the last app that made you feel stupid. Using this guide, name the exact stage that failed (perceive, attend, remember, decide, act, feel) and the mechanism. Then find one place where your own product does the same thing to someone else.

Reading list

  • The Design of Everyday Things (revised edition, 2013)
    Don Norman · mental models, signifiers, the gulfs of execution and evaluation; the foundation for this whole guide.
  • Designing with the Mind in Mind (3rd edition, 2020)
    Jeff Johnson · the best single book on perception, attention and memory written for interface designers.
  • The Humane Interface (2000)
    Jef Raskin · locus of attention, habituation and modes, argued with rigor and strong opinions.
  • Thinking, Fast and Slow (2011)
    Daniel Kahneman · System 1 and 2, heuristics and biases, peak-end. Read the priming chapter with the replication caveat in mind.
  • Don't Make Me Think, Revisited (2014)
    Steve Krug · satisficing and scanning in plain language; a two-evening read.
  • Laws of UX (2020)
    Jon Yablonski · compact chapters on the most-cited laws; pair it with this guide's evidence ratings.
  • Information Visualization: Perception for Design (4th edition, 2020)
    Colin Ware · the deep reference on preattentive features and visual search.
  • Emotional Design (2004)
    Don Norman · the visceral, behavioral and reflective levels.
  • Flow (1990)
    Mihaly Csikszentmihalyi · the conditions for absorbed, optimal experience.
  • Tiny Habits (2019)
    BJ Fogg · B = MAP in practice; read it alongside the ethics questions in chapter 19.
  • "The magical number 4 in short-term memory" (2001)
    Nelson Cowan, Behavioral and Brain Sciences · the modern capacity estimate and why 7 is not it.
  • "The Magical Number Seven, Plus or Minus Two" (1956)
    George A. Miller, Psychological Review · short, witty, and very different from how it is quoted.
  • "F-Shaped Pattern of Reading on the Web: Misunderstood, But Still Relevant" (2017)
    Kara Pernice, Nielsen Norman Group · the corrected story of the F-pattern and the other scanning patterns.
  • Nudge (2008; final edition 2021)
    Richard Thaler and Cass Sunstein · choice architecture and defaults.
  • Calm Technology (2015)
    Amber Case · principles for technology that respects attention.

Next: put the user's mind to work on the right problem in Problems Worth Solving, or go straight to the perception-heavy guides, Visual Design and Typography.