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)
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?
Visible options are read, not remembered, so the working-memory limit does not set a menu size. Cowan's later estimate of about four chunks is real, but it applies to what you must hold in mind, which is why it matters for multi-step flows, not for a list on screen. Chapter 9 untangles this.
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?
Pointing time depends on distance and target size (Fitts's law, chapter 13). Color and motion help people find a target, but once found, acquisition time is physics. The shortcut removes pointing altogether.
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?
The famous jam study is real, but later meta-analyzes found the average effect close to zero, with overload appearing only under specific conditions. Chapter 16 covers what those conditions are.
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.
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.
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
No edges, no prediction. "here" and "Open" look exactly like text, so the brain predicts "nothing to press". People hunt by hovering.
Do
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?
Peripheral vision cannot read small text, and a color change of a tiny label is easy to miss. Move the signal toward the locus of attention, or make it a large, persistent cue (for example a change in the editor's own frame). Red in the same corner helps a little, but the location is the real problem.
Exercise 1.1 30 minutes · on your own product
The blur and grayscale pass
Take full-size screenshots of your three most-used screens.
Blur each by about 8 px. Write down the first three things you notice on each, in order.
Write next to them the three things a new user should notice, in order.
Convert the originals to grayscale. Circle every control or group that loses its edge.
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.
Beginner
Competent
Strong
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.
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
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.
Grouped gaps: 3 px between label and field, 20 px between fields, 34 px between the "name" pair and the "contact" pair. No borders were added, yet you now see two groups of two.
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
Boxes everywhere cancel out. Each row has its own region, so nothing is grouped and "Sign out" looks as harmless as "Font size".
Do
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?
The labels are ambiguous because proximity is equal in both directions. Fixing the spacing ratio makes each label belong to one field and adds no ink. Borders would also work but add noise; color would create false similarity groups.
Exercise 2.1 40 minutes · on your own product
Draw the groups people see
Pick your densest screen. Print it or put it in a drawing app.
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.
Now list the groups you intended (from your data model or the user's task).
Mark every place where a perceived group does not match an intended one.
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.
Beginner
Competent
Strong
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.
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
Nothing to complete. The row ends at the edge, so the brain closes it: "that is all there is".
Do
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?
When the row fits exactly, closure completes it and the brain concludes it ends. A peeking item is the cheapest, quietest signal. A label works but adds noise; auto-scroll steals attention and is hostile to readers.
Exercise 3.1 25 minutes · on an app you use daily
Gestalt spotting walk
Open three apps you use every day (for example your mail, notes and a reader).
Find one clear instance each of continuity, closure, figure-ground, common fate and Prägnanz. Screenshot them.
Find one place where a principle produces a wrong reading (an accidental group, an ambiguous layer).
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.
Beginner
Competent
Strong
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.
Lab: find the target
Find the yellow circle and click it.
Choose a search type and press Start.
Do five feature searches at 8 items and five at 64, then the same for conjunction. Feature times should barely change with more items. Conjunction times should climb, because you are checking items one by one. Times are logged per run; nothing leaves your browser.
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:
Feature
Strength in UI
Use it for
Watch out
Color (hue)
Very strong when only one or two items differ
Unread dots, errors, the one primary button
Fails for color-blind users unless lightness also differs
Lightness / contrast
Very strong
Selected state, primary text vs secondary
Low-contrast "subtle" states vanish
Size
Strong
Headlines, key numbers
Small size differences (14 vs 15 px) do not pop
Orientation
Moderate
Chevrons, rotated disclosure triangles
Rarely useful for large areas
Motion / flicker
Strongest of all, especially in the periphery
Truly urgent changes
Impossible to ignore, so it steals focus; respect reduced motion
Enclosure, added marks
Strong
Badges, focus rings, a dot
Many 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?
With four colored states, overdue is just one color among several, so it does not pop. Quieting the rest restores pop-out; sorting reduces the search set. Animation would work but costs attention every time the screen is open.
Exercise 4.1 30 minutes · on your own product
The salience budget
On your main screen, list every element that uses a saturated color, bold weight, badge, icon-in-color or motion.
Rank them by how important it is that the user sees them within one second.
Keep pop-out for the top one or two. Demote the rest to the quiet baseline.
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.
Beginner
Competent
Strong
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
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.
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?
The reload blanks the screen (change blindness) and the summary is far from attention. An in-place update keeps the motion cue, and a persistent chip near the table header puts the state where people look. Bold or a toast help briefly but the state must stay visible.
Exercise 5.1 45 minutes · on your own product
The silent-change hunt
List every action in your product that changes something other than what was directly clicked (totals, sync state, sort order, other panes).
For each, write where the change appears and where the user's eyes are at that moment.
Mark each "seen" or "likely missed".
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.
Beginner
Competent
Strong
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?
Three effects stack: salience spent on everything, regions that do not differentiate, and a blank-screen refresh that erases the motion of the change. Quiet tiles, grouped by meaning, with in-place updates and a single alarm color, fix all three. Data display is covered in depth in Information & Data.
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.
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
Looks like an ad, treated as an ad. Right-rail, bright box, promotional style: the very things that trained users to ignore ads.
Do
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?
The banner is already invisible through banner blindness. Escalating loudness becomes harassment (see Honest & Calm). Relevance and placement at the locus work better than volume.
Exercise 6.1 30 minutes · on your own product
Map the locus
Pick your product's core task and break it into 5–8 steps.
For each step, mark on a screenshot where the user's locus of attention is.
Mark every piece of feedback, status or message the product shows during that step.
Draw an arrow from each message to the locus. Long arrows are problems.
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.
Beginner
Competent
Strong
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).
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
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?".
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.
Chunk body text short. Two to four sentences per paragraph, one idea each.
Make the scannable things look scannable: bold key terms sparingly, numbers as digits ("3 days", not "three days"), lists for parallel items.
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?
Unstructured paragraphs produce the F: top lines get read, the rest gets a left-edge glance. Headings and front-loaded bullets let people layer-cake their way to the change that matters to them.
Exercise 7.1 30 minutes · on your own product or site
The headings-only test
Take your landing page, help page or any text-heavy screen.
Copy only the headings, bold text and link text into a blank document, in order.
Ask: could someone decide what to do from this alone?
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.
Beginner
Competent
Strong
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.
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?
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:
Level
When
How
Example
Interrupt now
Time-critical and personal
Push with sound, only on explicit opt-in
A ride has arrived; 2FA code
Notify quietly
Relevant soon, not urgent
Silent notification, badge
A friend commented
Batch
Useful in aggregate
Daily or weekly digest
New highlights this week
Ambient
Status that changes slowly
Shown in the UI when opened, no push
Sync status, storage used
Never
Exists to bring the user back
Do not send
"We miss you!"
Don't
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
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?
"Engagement" with an interruption often means people trying to make it go away. The drop in session length suggests broken flow. Move tips out of the writing moment entirely.
Exercise 8.1 40 minutes · on your own product
Notification triage
List every notification, email, badge, popover and in-app message your product can send.
Put each in a level from the table above (interrupt, quiet, batch, ambient, never).
For each "interrupt", write the user benefit in one sentence. If you cannot, demote it.
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.
Beginner
Competent
Strong
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?
Location, banner styling and focused attention combine. Better: autosave (remove the problem), or mark unsaved state at the locus (the document title or tab) and confirm before closing, which is exactly what most macOS apps do with a dot in the close button.
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.
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.
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.
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?
The best fix removes the memory task entirely. Shorter codes and chunking help when a code must be handled, but carrying it across screens is extraneous load you can design away.
Exercise 9.1 45 minutes · on your own product
Memory-load inventory
Walk through your core flow. At every step, write down what the user must remember from earlier (values, choices, names, where they came from).
Count the items held at each step. Mark any step above 3.
For each held item, choose: carry forward on screen, autofill, remove, or chunk.
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.
Beginner
Competent
Strong
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
Recall. Users must remember tag names and query syntax. Experts love it; everyone else is stuck.
Do
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.
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
Product
Users often believe
Reality
System-image fix
Cloud sync
Deleting a local file just frees space
It deletes everywhere
Say "Delete from all devices" in the confirmation
Thermostat
Setting it higher heats faster
Most heat at one rate
Show "Heating to 22°, about 15 minutes"
Shared doc link
Only people I sent it to can open it
Anyone with the link can
Show who can access, in words, next to the link
"Archive" in mail
Archive deletes
Archive files away, still searchable
Brief 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?
The users' model ("this device's storage") is reasonable; the system image did not correct it. A clear consequence at the moment of action fixes the model where it matters.
Exercise 10.1 50 minutes · with one other person
Draw their model
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.
Draw your own designer's model next to it.
Circle every difference. For each, find what in the system image taught the wrong idea.
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.
Beginner
Competent
Strong
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.
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?
Stable positions protect habits. New things can earn prime slots later, after you see real usage. A one-time announcement handles discovery without moving anything people tap daily.
Exercise 11.1 30 minutes · on your own product
A habit map
From analytics or your own memory, list the 10 most frequent actions in your product.
For each, note its position (screen, region, order) and its shortcut.
Mark which ones changed position in your last three releases.
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.
Beginner
Competent
Strong
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?
The flow combines a context switch with a memory task under time pressure. Accept paste, chunk the input, allow a little clock skew, and give recovery codes as a downloadable file plus a copy button.
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.
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
Everything weighs the same. The two formats 90% of people want are lost among rare ones.
Do
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?
The problem is unsorted scanning, not the number. Grouping and ordering turn a linear search into a quick jump. Hick's law is real but narrow; it is no reason to remove useful settings.
Exercise 12.1 35 minutes · on your own product
Weight the choices
Find the menu, picker or screen in your product with the most options.
Estimate (or measure) the share of use for each option.
Redesign it: one default or primary, a few secondary, the rest behind "More" or grouped and sorted.
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.
Beginner
Competent
Strong
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.
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.
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.
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
Guideline
Minimum target
Note
Apple Human Interface Guidelines
44 × 44 pt
For iOS and iPadOS touch targets
Material Design
48 × 48 dp
Visual icon can be smaller; the hit area is 48
WCAG 2.2, 2.5.8 (AA)
24 × 24 CSS px
Or enough spacing around smaller targets
WCAG 2.2, 2.5.5 (AAA)
44 × 44 CSS px
The 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
Small, far, adjacent. Slow to hit, and a slip deletes instead of saves.
Do
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?
The top-left is the hardest reach for a right-handed one-handed grip, and 28 px is under the minimum. Moving the action into the easy zone and enlarging it attacks both D and W. A label helps understanding but not reach.
Exercise 13.1 40 minutes · on your own product
Hit-area audit
In browser dev tools, add a temporary outline to all button, a, [role=button] to see hit areas.
List every target under 44 × 44 px and every destructive target within 8 px of a frequent one.
On mobile, screenshot your main screen and overlay a thumb-zone sketch. Note primary actions in the hard zone.
Fix the three worst offenders.
You're done when: you have an outlined screenshot, a list of offenders, and three fixes shipped.
Beginner
Competent
Strong
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:
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:
Acknowledge within 0.1 s. The button visibly presses, the row highlights. This is the most important rule; it tells people their action registered.
Delay the spinner. Show busy indicators only if the wait passes about 300–500 ms, so fast actions do not flash.
Optimistic updates. Show the result immediately and sync in the background, with a clear and recoverable failure state.
Skeletons and progressive loading for content screens, so structure appears before data.
Determinate progress for long tasks: a bar that moves steadily feels shorter than a spinner. Tell people what is happening ("Importing 1,240 notes").
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?
At 40 s, attention will leave anyway. Determinate progress makes the wait predictable, background work respects the user's time, and the notification closes the loop.
Exercise 14.1 45 minutes · on your own product
A latency budget
List your 5 most frequent actions.
Measure each with the network throttled to Slow 4G (use the Performance panel or simple timestamps).
Classify each as under 0.1 s, under 1 s, under 10 s, or over.
For each action over its target, choose: make faster, acknowledge instantly, go optimistic, or move to background.
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.
Beginner
Competent
Strong
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.
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
Front-loaded learning. Active users skip it; those who read it forget it before they need it.
Do
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?
Satisficing users will not read a trade-off essay at minute zero. A good default, plus a cheap way to change later, respects both System 1 now and System 2 when it matters.
Exercise 15.1 40 minutes · on your own product
The first-minute rewrite
Install your product fresh (or use a clean account). Time how long until you can do one piece of real work.
List every screen, choice and instruction before that point.
For each: delete it, defer it until it is relevant, or replace it with a default.
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.
Beginner
Competent
Strong
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.
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
Defaults, anchors and loss framing used against the user. Pre-checked add-on, invented "original" price, shaming decline.
Do
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?
The complaint is preference uncertainty and hard comparison: exactly the conditions where overload appears in meta-analyzes. Clear comparison and a recommendation address them. A countdown is a dark pattern.
Exercise 16.1 40 minutes · on your own product
Default and frame review
List every default in your product (settings, form pre-fills, notification opt-ins, plan selection, sort orders).
For each, write who benefits from it: the user, you, or both.
Change any default that benefits only you.
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.
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.
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.
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?
Memory weights the worst moment heavily, and that moment destroyed trust. Remove the negative peak first; positive endings come after.
Exercise 17.1 45 minutes · on your own product
Draw the experience curve
Pick one complete journey (first launch to first success, or a weekly routine).
Draw it as a curve like the one above: mark every moment that feels better or worse than neutral.
Circle the lowest point and the end.
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.
Beginner
Competent
Strong
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.
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.
Law
Kind
Use it to ask
Tesler
Rule of thumb
"Who is carrying this complexity, and can my code carry it instead?"
Postel
Engineering principle
"Am I rejecting input whose meaning is clear?"
Jakob
Observation
"Is breaking this convention worth the cost every user pays?"
Occam
Philosophical principle
"Could this work with one fewer part?"
Pareto
Statistical 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?
The fixed complexity (currency, category, date) is being carried by the user every time. Defaults move it into the software, and the full form stays available for the exceptions.
Exercise 18.1 50 minutes · on your own product
Move one burden into code
Find the most frequent form or input in your product.
List every field and every validation rule.
For each field: can it be defaulted, inferred, remembered or parsed? For each rule: is it rejecting clear input?
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.
Beginner
Competent
Strong
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?
Each law answers a different question: where and how big (Fitts), how much to ask (Tesler, Hick, defaults), how fast (response limits), how to recover (undo). Together they produce the add-task flows of the best to-do apps, such as Things' Quick Entry.
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.
Three needs. After Deci and Ryan. A product people love usually satisfies at least two.
Need
Supports it
Thwarts it
Autonomy
Real choices, customization, easy export, no lock-in, explaining why
Clear feedback, visible progress, mastery paths, shortcuts, good errors
Unclear state, failure without explanation, condescending hand-holding
Relatedness
Sharing, collaboration, acknowledgement from real people, a human voice
Fake 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.
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.
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?
User-chosen timing respects autonomy and times the prompt to when they can act; a one-line entry raises ability; no punishment avoids the guilt that makes people leave.
Exercise 19.1 40 minutes · on your own product
B = MAP and SDT audit
Pick the one behavior that defines success for your users (write a note, read an article, log a workout).
Map it: what prompts it? How many steps and seconds does it take (ability)? Where does motivation come from?
Reduce the steps for the first action to the minimum.
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.
Beginner
Competent
Strong
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:
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.
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:
Signal
Builds trust
Erodes trust
Care and polish
Consistent details, no broken states, good typography
Misaligned UI, lorem ipsum, broken images
Transparency
Clear pricing, plain privacy terms, honest status pages
Never losing data, predictable behavior, honest error messages
Lost work, silent failures, "something went wrong"
A human
A named maker, real replies, a changelog
No contact, no history, fake testimonials
Don't
Cute at the worst moment. Playful tone at a negative peak reads as not caring. Did my note save? No one knows.
Do
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?
Basics only matter when missing, and when missing they dominate. Fix the foundation; the confetti can stay (ideally optional).
Exercise 20.1 45 minutes · on your own product
Three-level review and trust inventory
Write one paragraph each on how your product performs at the visceral, behavioral and reflective levels. Be specific.
Sort your features into Kano categories: basic, performance, delighter. Mark any basic that is unreliable.
List your trust signals using the table above. Mark missing ones.
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.
Beginner
Competent
Strong
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?
Option a uses each mechanism in the reader's own interest. Option b uses the same mechanisms (prompt, loss aversion, extrinsic rewards) against autonomy, and option c risks shame instead of relatedness.
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.
Law
What it says
Evidence
Design implication
Example
Gestalt grouping
Proximity, similarity, region and connection create perceived groups
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
Start from an observed problem, not a law. "People miss the error" comes first; "change blindness" is the explanation that suggests fixes.
Check the evidence column before betting a design on a law. Heuristics are prompts for thinking, not proofs.
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.
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?
The action has no signifier (perception) and relies on recall (memory). A visible alternative and clear drop feedback fix both; size and number of folders are irrelevant until people know dragging exists.
Exercise 21.1 90 minutes · on your own product
The full cognitive audit
Pick your product's core flow, start to finish.
Run the checklist below on it, honestly, one item at a time.
For every unchecked item, write the screen, the stage and a proposed fix.
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.
Beginner
Competent
Strong
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
Perception is prediction. Conventions and clear edges let people's brains guess right.
Group with space first, regions second, lines last. Spacing is meaning.
Pop-out works only on a quiet background. Spend salience on one or two things.
If a change is not at the locus of attention, assume it was not seen.
People scan for anchors; give them meaningful headings and front-loaded words.
Working memory holds about four chunks. Never make people carry information between screens.
Habits are tied to position. Keep frequent controls where they are; prefer undo to confirmation.
Bigger and closer is faster. Acknowledge every action within 0.1 s.
Defaults, anchors and frames shape choices. Use them for the user, never against them.
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.
Day
Practice
Artefact
1
Blur and grayscale pass on your three main screens (Ex. 1.1)
Annotated screenshots
2
Draw perceived groups vs intended groups (Ex. 2.1)
Grouping map and one spacing fix
3
Gestalt spotting in three daily apps (Ex. 3.1)
Six annotated screenshots
4
Salience budget (Ex. 4.1) and silent-change hunt (Ex. 5.1)
Ranked salience list, side-effect table
5
Locus map (Ex. 6.1) and headings-only test (Ex. 7.1)
Annotated flow strip, rewritten headings
6
Notification triage (Ex. 8.1)
Triage table, one notification removed
7
Rest and reflect: which three ideas changed how you see your product?
Half-page reflection
8
Memory-load inventory (Ex. 9.1) and habit map (Ex. 11.1)
Load table, stability contract
9
Draw a friend's mental model (Ex. 10.1)
Two drawings and one system-image fix
10
Weight the choices (Ex. 12.1) and hit-area audit (Ex. 13.1)
Redesigned menu, three target fixes
11
Latency budget (Ex. 14.1)
Budget in README, one action improved
12
First-minute rewrite (Ex. 15.1) and default review (Ex. 16.1)
Time-to-first-work, default inventory
13
Experience curve (Ex. 17.1) and move a burden into code (Ex. 18.1)
Curve with worst moment fixed
14
Full 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.