Jakob Nielsen：用户预期经济学与AI时代的 Jakob 定律

Summary: Users judge every new design against mental templates assembled from thousands of old ones. Familiar controls put that training to work for you, so interfaces should look like what they are and behave like what they resemble. I explain which expectations to honor, and when an improvement is worth the relearning, through 7 principles from psychology and design: Jakob’s Law, mental models and schemata, least astonishment, representativeness, signifiers, mere exposure, and the MAYA principle.

(All illustrations in this article made with GPT Image 2.5 Sunburst.)

This article runs to almost 10,000 words because it covers an expansive territory of UX theory and advice and surveys 125 years of research literature. For a short overview, watch my 6-minute animated explainer video (YouTube).

Users arrive at your product pre-trained at other companies’ expense. Before anybody meets your design, thousands of websites, apps, stores, doors, and forms have shaped his or her expectations: what a button looks like, where search lives, what “Cancel” does, and how a checkout proceeds.

In machine-learning terms, your onboarding is a fine-tuning run lasting a few seconds, applied to a foundation model built from billions of prior exposures. Your product runs in the user’s head, and that head was trained on everybody else’s products.

Users arrive at your product pre-trained at other companies’ expense. Defy the conventions, and you ask them to unlearn those lessons on your doorstep.

In 4 decades of watching users, I’ve seen designs fail from violated expectations far more often than from missing features. This article connects 7 principles and findings: Jakob’s Law, mental models and schema theory, the principle of least astonishment, the representativeness heuristic, signifiers, the mere-exposure effect, and the MAYA principle. They come from different research traditions, yet they agree that expectations make or break the user experience.

Expectations have an economy of their own. You can borrow them through conventions and bank them through consistency. Violate them, and you tax your users. Innovate, and you spend from a limited budget. Run this economy wisely, and usability follows.

The expectation economy: an analogy that doubles as a mental model.

A warning to my fellow AI enthusiasts: conversational AI and agents make each of these laws bite harder, as the following sections show.

Conversational AI and agents raise the stakes for every law of user expectations.

Jakob’s Law: Users Spend Most of Their Time on Other Sites

I formulated Jakob’s Law of the Internet User Experience in 2000: users spend most of their time on other websites, so they expect your site to work like the other sites they already know. (Yes, I named it after myself. The branding worked.) The law extends beyond websites to any setting where people move freely among designs without committing to one. In 2026, that includes AI.

The arithmetic is stark. Suppose you run a successful product, and a devoted user gives you 10 minutes a day. If that user spends 7 hours a day looking at screens, your slice is 2.4%. (The numbers are rough; any reasonable estimate yields the same conclusion.)

The remaining 97.6% of that user’s screen time belongs to other companies’ designs, which supply most of his or her training. You inherit the graduate.

Users spend most of their time on other sites, which do the training. You inherit the graduate.

Thus, conventions rule. A design convention is a crowdsourced mental model. Nobody decreed that the logo sits at the top left and links to the homepage, that search lives near the top of the page, or that a cart icon holds purchases-in-waiting. Billions of exposures across millions of sites did the teaching, and every user carries the diploma.

Conventions let your product inherit that training free of charge. Defy them, and users must unlearn those lessons on your doorstep.

A design convention is a crowdsourced mental model. Deviate from it only when your alternative serves users much better.

Psychologists call the mechanism transfer of learning. Edward Thorndike and Robert Woodworth showed in 1901 that skill transfers between tasks only to the extent that they share identical elements. Conventions create positive transfer.

Near-conventions, by contrast, can produce negative transfer. Elements that look identical but behave differently turn the old skill into a liability, like a light switch installed upside down.

An obviously novel control at least earns the user’s attention. A familiar-looking control that misbehaves earns a confident, wrong click. Masahiro Mori described the uncanny valley for robots in 1970, and interaction design has one too. Almost-standard can be worse than plainly different.

Near-conventions cause negative transfer: a familiar-looking control that misbehaves earns a confident, wrong click. Driving on the “wrong side” of the road abroad shows why almost-standard can be worse than plainly different.

The law has teeth. In a study I cite in my Jakob’s Law article, centering the logo instead of placing it at the top left raised the share of users who failed to reach the homepage in one click from 4% to an eye-popping 24%. That’s a sixfold increase in failure from one small deviation that some designer no doubt found more elegant. Scroll-hijacking, another fashionable deviation, commandeers the scroll wheel that users expect to move the page at their own pace, and leaves them disoriented.

Centering the logo raised the share of users who failed to reach the homepage in one click from 4% to 24%. Some designer no doubt found it more elegant.

Deviate only when your alternative substantially improves the user experience. A marginal gain or a fresher portfolio piece doesn’t justify the cost. Occasionally, a much better deviation becomes the next convention, and everybody else copies it.

Most deviations don’t earn that distinction. Most are ego with a style guide.

Most deviations from convention never earn the right to become the next standard. Most are ego with a style guide.

AI Gets Its Own Jakob’s Law (and a Reverse One)

Restate the law for 2026: unless you happen to be OpenAI, Google, or Anthropic, users spend most of their AI time in other AI products, so they expect yours to work like the market leaders they already know. Hundreds of millions of people have internalized the prompt box at the bottom, the streaming reply, the stop button, the conversation list in a side rail, and the regenerate and copy buttons. These conventions are less than 4 years old, and violating them already collects the same tax from users.

Unless you’re a market leader, users spend most of their AI time in other AI products, so they expect yours to work like the chatbots they already know.

Three twists refine this version of the law. First, conversational AI inherits the oldest convention set on Earth: human conversation, with turn-taking, politeness, and the assumption that the other party remembers what was said three turns ago. An AI that loses the thread violates expectations older than the alphabet.

Second, AI conventions are wet cement, much as website conventions were in 1995. They’re still setting, and the biggest products leave the deepest footprints. So adopt emerging standards early, track them quarterly, and save your inventiveness for capabilities, where it pays.

The third twist is reverse Jakob’s Law: expectations formed in AI now spill back into legacy software, exposing its rigidity. For 30 years, users tolerated search bars that matched only exact keywords, filters that demanded 12 checkbox clicks, and forms that rejected a phone number over a stray parenthesis. Every other site was equally literal-minded, so rigidity was the convention.

That tolerance has expired. An hour a day with an AI that understands messy intent and repairs bad phrasing makes yesterday’s standard web search feel brain-dead.

AI is raising the baseline expectation of intent tolerance across all software. And AI products now train your users’ expectations even if your own product contains no AI at all.

Reverse Jakob’s Law: once users get used to AI’s intent tolerance, rigid legacy forms and keyword-only search feel brain-dead.

Mental Models and Schemata: The Brain Autocompletes Your Design

Roughly a third of Americans believe their home thermostat works like a car’s gas pedal: crank it to 90 degrees, and the house heats faster. It doesn’t.

A thermostat only switches the furnace on or off. Setting it to 90 doesn’t make the furnace work any harder. It just keeps the furnace running until the house reaches a sweltering 90. But people who hold the gas-pedal belief jack up the temperature to warm a cold room quickly, forget to turn it back down, and roast all evening.

Willett Kempton documented these competing “feedback” and “valve” theories of home heating in a 1986 paper, estimating that 25–50% of Americans held the physically wrong valve model. One humble thermostat captures the whole problem. People can act logically and still go wrong, because their model is wrong.

Up to half of Americans hold the valve model of home heating: crank the thermostat to 90, and the house heats faster. The model is wrong, but the behavior follows logically from it.

Definition: A mental model is a person’s internal representation of how something works: a simplified, often incomplete theory that lets him or her predict what a system will do and decide how to act on it. The critical word is simplified.

Nobody carries an accurate blueprint of a website’s architecture or an operating system’s file structure. But a rough working theory is usually enough to complete a task, even when it’s wrong in consequential ways.

The concept traces to the Scottish psychologist Kenneth Craik, whose 1943 book The Nature of Explanation proposed that the mind builds “small-scale models” of reality to anticipate events. The idea then slumbered for 4 decades, until Philip Johnson-Laird’s book Mental Models and a companion collection edited by Dedre Gentner and Albert Stevens (both published in 1983) brought it into the mainstream. From there it entered human–computer interaction and never left.

A mental model earns its keep by predicting the outcomes that matter, even when it isn’t perfectly true. Engineers still build bridges with Newton’s physics, despite Einstein’s more complete account, because Newton predicts accurately enough for the loads a bridge will carry.

Kempton’s valve theorists correctly predicted that the room would get warm, but their model failed where the thermostat’s behavior diverged from a valve’s. A serviceable model that’s wrong in harmless places beats an accurate model nobody can hold.

Two models are always in play: the user’s (how he or she thinks the system works) and the designer’s (how the designer understands it to work). The interface is the bridge between them. Don Norman calls it the system image: the screens, labels, behaviors, and documentation from which the user’s model is assembled, often without the designer ever speaking to the user.

The builders hold a detailed model because they built the system. Users must construct their own model from whatever evidence the product gives them, like detectives working from a few smudged clues. That gap breeds many usability problems. I’ve repeated the resulting slogan for decades: you are not the user.

Schema theory explains the machinery underneath.

Definition: A schema (plural: schemata) is an organized knowledge structure that encodes what things are, how they relate, and what usually happens next. Perception and memory reconstruct reality by fitting incoming details to the nearest stored template and filling gaps with that template’s defaults.

Immanuel Kant used the term in 1781, Frederic Bartlett made it empirical in 1932, Jean Piaget built a theory of child development around it, and David Rumelhart’s 1980 chapter crowned schemata “the building blocks of cognition.” Few ideas in cognitive science have aged better.

Bartlett’s method in his 1932 book Remembering was elegantly simple. British participants read “The War of the Ghosts,” a Native American folktale full of unfamiliar imagery and events, then retold it, some repeatedly over months.

The retellings drifted in three systematic ways: assimilation (canoes became boats, and seal hunting became fishing), leveling (odd details dropped out), and sharpening (selected details became more pronounced). Memory rebuilt the story from the nearest available templates.

Your users do the same to your interface. The brain autocompletes. Users look for a search box where search boxes usually live, whether or not you put one there, and they later remember your checkout as working like every other checkout. Fight the template, and the template usually wins.

The brain autocompletes: users look for a search box where search boxes usually are, whether or not you put it there.

Users arrive with rich schemata built through prior experience. Match them, and you get usability without training. Every gratuitous deviation adds schema debt: users pay in errors and hesitation, while you pay in lost conversions and support tickets.

When you find a gap between the user’s model and your system, you have three possible repairs. Try them in this order:

1. Change the design to match the model users already have. This is almost always the right answer.

2. If you can’t match the existing model, make the correct model easy to form through visible state, honest labels, and feedback that shows the consequences of actions.

3. Only as a last resort, teach the new model, accepting that most users skip instructions. Forcing users to abandon working models because your team prefers its invention is Procrustean design: stretching the guest to fit the bed. (Theseus killed Procrustes with his own method, a fate worth pondering during your next redesign review.)

Procrustean design forces users to abandon working mental models because the team prefers its invention. Change the design first; teach a new model only as a last resort.

How do you find the gaps? Watch real users. When somebody does something that makes you mutter, “Why on earth would they do that?” you’ve located a possible divergence between that user’s model and yours. Treat that baffling action as data about the user’s model rather than as user error. In tests with 5 users, mismatches often surface quickly as person after person makes the same wrong prediction.

The three steps to fix mental model mismatches: A good tailor alters the suit to fit the customer. Procrustes worked the other way around, using a torturous version of step 3.

Hesitation flags the visible breakdowns, but some of the costliest misunderstandings produce a perfectly confident click. To uncover a mental model in your next usability study, choose an action whose consequences differ under two plausible models. Before revealing what happens, ask users to predict the outcome.

To uncover a mental model, choose an action whose consequences differ under two plausible models, and ask users to predict the outcome before you reveal it.

Folk Models of AI Are Wrong in the Wrong Places

Users hold folk models of AI, and each can distort how they use the system. The “database” and “search engine” models suggest faithful retrieval, so hallucination feels like lying (a database doesn’t invent rows).

The “person” model is the strongest autocomplete of all. Fluent turn-taking triggers the human-conversation schema, and users fill the gaps with human defaults. They may assume the system remembers last month’s chat, knows when it’s unsure, and means what it says. None of these folk models fits how a large language model behaves.

Schemata activate as bundled packages, which raises the stakes. When an interface exhibits one high-salience human trait, such as articulate prose, schema contagion does the rest.

The user’s brain may then assume the rest of the human repertoire: common sense, episodic memory, awareness of ignorance, and basic arithmetic. Across 300,000 years of human interaction, those traits traveled together. A colleague who wrote like a Rhodes Scholar could still count the letters in a word.

Schema contagion: one high-salience human trait, such as articulate speech, makes people import the full human package, including judgment the system may lack.

AI breaks that correlation with jagged competence: superhuman at synthesis yet prone to trivial logical errors, with an invisible boundary that shifts with every model release. When a system with a Ph.D. vocabulary commits a kindergarten blunder, it can trigger schema shatter, and the user may swing like a pendulum from reckless overtrust to blanket dismissal. A footer disclaimer can’t contain schema contagion, because fluent prose reactivates the human schema on every turn.

For the first time in my 43 years in UX, I can only partly use repair number one (change the design to match the user’s model), because the technology’s core behavior stays probabilistic no matter what we wrap around it. Thus, AI design must lean unusually hard on repair number two: help users form a workable new model by showing sources, exposing what the system can and can’t see (context indicators beat fine-print disclaimers), and stating capabilities in the interface at the moment of use.

As with the thermostat, a serviceable model will do. A well-read temp with amnesia, who works only from what’s on the desk and never admits to guessing, is a model that prompts the right habits. For agents, the user needs a mental model of a delegation contract: what the agent may touch on its own and what requires permission. Hide those boundaries in a settings page, and the user’s schema will happily autocomplete the wrong ones.

Agents need a delegation contract that spells out what they may do on their own and what requires permission. Leave the boundaries loose, and they get interpreted creatively.

The Principle of Least Astonishment: Surprise Is a Usability Bug

Definition: The principle of least astonishment (POLA, also known as the principle of least surprise) states that when several design alternatives satisfy the requirements, you should choose the one that violates the fewest user expectations.

The principle has a paper trail, and it starts with programmers, who were its first victims and its first advocates. The earliest documented sighting of the “Law of Least Astonishment” dates to 1967 in the PL/I Bulletin, where programmers griped about IBM’s new PL/I language, whose type-conversion rules produced arithmetic surprises. By 1972, programming-language literature stated the law explicitly: every construct should behave as its syntax suggests, and language designers should honor established conventions.

Mike Cowlishaw of IBM turned the folklore into an engineering method when designing the REXX language. He screened each candidate feature for its astonishment factor: a feature that misfires unpredictably “has a high astonishment factor and is therefore undesirable” (IBM Systems Journal, 1984). Eric Raymond later canonized the idea as the Rule of Least Surprise in The Art of Unix Programming (2003).

The strong word is deliberate. Astonishment is the moment a user mutters, “What just happened?” At that moment, the design has failed, whatever the spec says.

Every astonishment collects a surprise tax: a beat of hesitation, a wrong click, an error to recover from, and a small withdrawal from the user’s trust in your brand. Each tax is tiny. Across a purchase funnel, they compound into abandonment.

Every astonishment collects a surprise tax: a hesitation, a wrong click, and a small withdrawal of trust. Across a purchase funnel, the taxes compound into abandonment.

Example: A subscription-cancellation dialog asks “Cancel subscription?” and offers two buttons: “Cancel” and “OK.” Nothing in the labels reveals which button stops the charges. Somebody shipped it anyway.

A cancellation dialog that offers “Cancel” and “OK” leaves users guessing which button stops the charges.

Why do surprises hurt so much when the fix is a glance away? Because conventions live as habits, and habits fire before users consult their knowledge. Paul Fitts and Michael Posner described skill acquisition in 1967 as three stages: cognitive, associative, and autonomous. Experienced users run your genre’s routines on autopilot in the autonomous stage. A violated convention drops them back into the cognitive stage in mid-task, like a touch typist suddenly forced to hunt for keys.

Don Norman named the resulting slip a capture error in 1981: the familiar sequence captures behavior even when the person knows better. By the time knowledge catches up, the habit has already acted. So design for the reflex, because it fires first.

Habit executes the familiar sequence before knowledge can intervene, even when the user knows better.

Predictability is the cheapest usability you can buy, because every convention you honor imports training that somebody else paid for: Ctrl+Z for undo, Esc to close a dialog, swipe-back on mobile, and the primary action where the platform’s dialogs usually put it. Consistency has been heuristic 4 on my list of 10 usability heuristics since 1994, and POLA is its enforcement arm. Amusement parks sell astonishment; software teams pay for it in support tickets and abandoned carts.

My operational test: watch 5 users attempt your core task. If 2 hesitate at the same control, you’ve located a surprise-tax collection point. Fix it before polishing pixels. (No, the 2-of-5 threshold isn’t carved in stone because a qualitative study doesn’t support firm stats. But as a rule of thumb, it has served me well for decades.)

Teams abuse the principle in two ways. First, they use it as a status-quo shield to veto improvements, forgetting that keeping a broken flow taxes every future user to spare a few veterans. Run the total arithmetic, including future users, before giving in to nostalgia.

Second, teams substitute their own expectations for users’. After 6 months on a project, everything feels obvious to you, including things nobody else could guess. Test with people who have never seen the product, because they’re the only ones still capable of being astonished.

Sometimes innovation justifies surprising users. When it does, astonish with airbags: announce the change, show a preview, keep the old behavior as the default at first, and put undo one click away. Astonish on purpose, never by accident.

When innovation requires astonishment, astonish with airbags: announce the change, show a preview, keep the old behavior as the default at first, and put undo one click away.

Keep two kinds of surprise apart. Outcome surprise, a result better than expected, is delight. Operation surprise, a control behaving contrary to expectations, is astonishment. And no amount of delight at the destination redeems a confusing journey.

User experience has good surprises and bad surprises. Don’t confuse the two.

Chatbots Astonish with Words, Agents with Actions

AI products are astonishment machines by construction. The same prompt can yield different outputs on different days, which breaks a deep software convention: same input, same output. Computing spent 50 years teaching users that machines are deterministic, and generative AI repealed the rule without telling anybody. Designers can’t eliminate variability, but they can make it legible by presenting alternatives as explicit drafts, labeling regeneration as a request for a new draft, and keeping yesterday’s saved answer fixed.

Generative AI repealed the convention that the same input produces the same output. Label regeneration clearly so users know they’re requesting another draft.

For agentic AI, the stakes jump from pixels to consequences, because an agent astonishes with actions. It can book the wrong flight, email the wrong list, or delete the wrong file. The classic remedies become mandatory: preview before execution, visible state during execution, an activity log after execution, and undo for everything the agent touches.

Grant autonomy as you would to a new human assistant: suggestions first, then requests for approval, then independent action on small tasks, with the user controlling each promotion. An assistant who keeps astonishing the boss gets fired. Agents that keep astonishing their users get uninstalled.

Grant autonomy in steps, with the user controlling each promotion. Agents that repeatedly astonish their users will eventually be dismissed.

The Representativeness Heuristic: Users Judge Your UI by Its Costume

Definition: The representativeness heuristic is a mental shortcut in which people judge the probability that A belongs to category B by how closely A resembles their prototype of B, while neglecting base rates, sample sizes, and logic.

Amos Tversky and Daniel Kahneman introduced the heuristic in 1972 and made it famous in their 1974 Science paper on judgment under uncertainty. Their showpiece is the Linda problem (1983): participants read a sketch of Linda (31, single, outspoken, a philosophy major concerned with social justice) and ranked statements about her.

85% of participants rated “bank teller and active in the feminist movement” as more probable than plain “bank teller,” which is logically impossible, since every feminist bank teller is also a bank teller. The sketch resembled the feminist prototype, and resemblance steamrolled logic.

In the Linda problem, 85% of participants rated “bank teller and active in the feminist movement” as more probable than plain “bank teller,” which is logically impossible. Resemblance steamrolled logic.

(Kahneman collected the 2002 Nobel in economics for this research program. Tversky had died in 1996, and the committee doesn’t award prizes posthumously.)

Users have little time to reason about your interface, so they classify pixels by resemblance too:

• Clickability is a costume. An element resembling the button prototype gets clicked. During the flat-design fad, plenty of real buttons shed the costume and turned invisible, while decorative boxes accidentally wore it and harvested futile clicks.

Clickability is a costume. Decorative elements that resemble buttons harvest futile clicks, while real buttons stripped of the costume go unnoticed.

• Whole pages have prototypes. A checkout page should look like a checkout, and a search results page should look like search results. Users recognize the category first and operate the specifics second.

• Trust is a resemblance judgment. In BJ Fogg’s Stanford study (2003, with 2,684 participants), 46% of the comments on website credibility concerned visual design, by far the largest category. And in 2006, Gitte Lindgaard and colleagues showed that people form a consistent visual-appeal judgment after seeing a page for just 50 milliseconds. Before reading a word, visitors judge whether your site resembles a legitimate business or a scam, so amateur typography can make an honest company wear the scam costume. Unfair, but predictable.

Trust is a resemblance judgment, and visual appeal gets judged within 50 milliseconds. An honest company with amateur design wears the scam costume anyway.

The dark-design industry runs on deception by costume: fake download buttons dressed as the real one, ads dressed as editorial content, counterfeit dialogs dressed as your operating system, and phishing sites dressed as your bank. Each works because the schema fires before scrutiny does. The design reads users’ minds and then picks their pockets.

The entire genre is user-hostile. Each deception also drains a commons that all designers share. Once users learn that costumes lie, they hesitate over your honest buttons too.

Dark patterns run on deception by costume. Phishing works because the schema fires before scrutiny does.

Teams deceive themselves by resemblance too. They recruit a participant who “looks like our persona” over one whose behavior matches the segment. They treat findings from 5-user qualitative studies as population statistics, a mistake Tversky and Kahneman diagnosed in 1971 as belief in the law of small numbers. Test with 5 users to find usability problems; measure conversion rates with thousands.

AI Fluency Wears the Expert’s Costume

Fluency masquerades as expertise. Confident, articulate prose signals a knowledgeable human, so users may trust a chatbot’s answer for no better reason than its eloquence.

The surface says “professor,” even when the answer lacks insight. The costume fits by construction, because a large language model is a representativeness engine, trained to produce plausible continuations of text. Its output can resemble the prototype of a good answer whether or not it is one.

Fluency masquerades as expertise. The surface says “professor,” even when the substance lacks insight, so pair fluent AI output with sources and ways to verify it.

Users can’t inspect the model’s interior, which makes calibration a design obligation: pair fluent output with sources, uncertainty markers, and verification affordances, so eloquence isn’t mistaken for accuracy.

Generative AI also industrializes costume crime. Polished prose, convincing logos, and cloned voices once required skill and money, and that cost gave users a rough clue to authenticity. Now any scammer gets all three for pennies. So honest products must strengthen signals that resemblance can’t easily fake, such as verified senders, consistent domains, and content provenance.

Finally, watch the costume of AI output inside your own organization. A hallucinated analysis arrives dressed like a diligent report, complete with headings, tables, and an executive summary, and reviewers extend it the credibility that such formatting has earned elsewhere. Judge AI work by checking its claims, because a well-cut suit can be empty.

A weak analysis arrives formatted like a diligent report. Judge AI work by checking its claims; elegant tailoring is no substitute for verification.

Signifiers: Look Like What You Are, and Say What You Can Do

The costume tells users what category a thing belongs to. A signifier goes further: it tells users what they can do. My good friend Don Norman introduced designers to the concept of affordances in his 1988 classic The Design of Everyday Things (in my opinion, still the best book ever written about user experience). He sharpened the terminology in his 2013 revision, following his 2008 essay “Signifiers, not affordances”: what matters in an interface is the signifier, the perceivable signal that communicates an action possibility.

A door handle that says pull, a raised button that says press, an underlined phrase that says click: with signifiers like these, a design explains itself without a manual. A door that needs a sign saying PUSH has already failed as a door.

A door that needs a sign saying PUSH has already failed as a door.

Together, representativeness and signification explain why interfaces should look like what they are. Every control must wear its true category and advertise its true operation. The flat-design fashion of the 2010s ran a decade-long natural experiment in stripping those signals, and users lost. Borderless buttons, links without underlines, and boxless fields forced people to hover, poke, and guess. I published my 86 guidelines for the 10 basic GUI widgets largely to repair that damage.

An invisible capability is a nonexistent capability.

Flat design stripped interfaces of their signifiers, and users lost.

Signifiers answer the first of two questions users ask of every control: “What can I do here?” The second is “What will happen if I do it?” Tom Djajadiningrat and colleagues named the answer to that second question feedforward in a 2002 paper cheekily titled “But how, Donald, tell us how?” Feedforward describes an action’s consequences beforehand; feedback reports them afterward.

A button label is a signifier; a “Delete 14 files?” confirmation that names the files is feedforward; the emptied folder is feedback.

Feedforward tells users what an action will do before they take it, just as feedback tells them what happened afterward.

Norman’s two gulfs, introduced in 1986, organize the trio. Signifiers and feedforward bridge the gulf of execution (how do I make it do what I want?), and feedback bridges the gulf of evaluation (did it do what I wanted?).

Signifier, feedforward, feedback: every control owes users three answers.

But there’s a catch: feedforward decays with mere exposure. Show a confirmation dialog 20 times a day, and Fitts and Posner’s autonomous stage swallows the safety check itself. Users stop reading the preview and click “Confirm” from muscle memory, and your airbag deflates into a ritual click before disaster.

The result is the airbag paradox: uniform friction breeds blind approval. For high-stakes or irreversible actions, especially with AI agents, feedforward needs anomaly-driven friction.

The airbag paradox: show a confirmation dialog 20 times a day, and habit swallows the safety check itself. Reserve interrupting confirmations for anomalous or high-stakes actions.

Let routine, reversible actions run silently with one-click undo, and reserve pre-execution previews for actions that are expensive, irreversible, or outside the user’s usual pattern. When you must stop the user’s hand, break your own dialog convention on purpose (for example, by requiring a specific choice rather than a habitual click on a green button). That’s one place in UX where a controlled dose of astonishment can be a feature, because it jolts the user out of the autonomous stage before a capture error costs real money.

The Best AI Products Are Rediscovering the Button

The chat box is a signifier vacuum: an empty rectangle that gives users no menu of capabilities, visible options, or clues about the system’s strengths and limits. Classic GUIs, whatever their faults, put commands on display; conversational UIs hide commands behind a blank stare. In Norman’s terms, chat widens both gulfs at once: users must guess what they can ask and how to phrase it, then guess whether the answer did what they asked.

The chat box is a signifier vacuum: one empty rectangle promises everything and indicates nothing.

Worse, the empty box demands that users compose elaborate prose to get good results. As I’ve argued in my analysis of the articulation barrier, roughly half the population in rich countries lacks the writing skill to articulate complex intent comfortably. These users need signifiers that show them what to ask for and how.

Example prompts, suggestion chips, slash commands, capability menus, and structured forms for frequent intents add familiar GUI signifiers to the conversation. The best AI products of 2026 are rediscovering the button.

The articulation barrier: an empty prompt box demands elaborate prose, and roughly half the population in rich countries lacks the writing skills to supply it.

For agents, replace scrolling text transcripts with persistent status chrome: a live dashboard of active tasks and affected objects. Without state signifiers, an agent becomes unaccountable, however magical it may feel.

The Mere-Exposure Effect: Familiarity Breeds Liking, Not Contempt

Definition: The mere-exposure effect is the increase in liking for a stimulus caused by repeated exposure to it, with no reward, persuasion, or interaction required.

Robert Zajonc of the University of Michigan chose the word mere with care. He titled his 1968 monograph “Attitudinal Effects of Mere Exposure” (PDF) to stress that exposure alone did the work. His participants saw nonsense words, Chinese-style ideographs, and yearbook photographs at varying frequencies, and the more often a stimulus appeared, the more they liked it.

Then it got stranger. In a 1980 Science paper, William Kunst-Wilson and Zajonc flashed irregular polygons for a single millisecond, far too briefly for conscious recognition. Asked which shapes they had seen before, participants performed at chance. Asked which shapes they liked, they reliably preferred the exposed ones. Liking without remembering. Robert Bornstein’s 1989 meta-analysis covered more than 200 experiments published from 1968 to 1987 and confirmed the effect across stimulus types.

History supplies a monument-sized demonstration. In 1887, Paris’s artistic elite petitioned against the planned Eiffel Tower as useless and monstrous. A few decades of exposure later, the “monstrous” tower had become the symbol of France itself.

Why should exposure breed liking? The best-supported answer is processing fluency: a familiar stimulus is easier to perceive, and the ease itself feels good. Piotr Winkielman and John Cacioppo showed in 2001 that easily processed pictures activated the smiling muscle without the participants noticing. Rolf Reber and co-authors, Winkielman among them, generalized the finding in 2004: anything that raises fluency (familiarity, symmetry, contrast, prototypicality) raises liking.

Processing fluency: a familiar design is easier to perceive, and the ease itself feels good, even when users don’t notice.

Hence, prototypes are beautiful. Jamin Halberstadt and Gillian Rhodes found in 2003 that digitally averaged birds, fish, and automobiles were all rated more attractive than individual specimens. For the automobiles, the one manufactured category, familiarity accounted for the preference.

So when users call a conventional design “clean” and an inventive one “cluttered,” they’re often reporting fluency rather than pixel counts. The interface that matches the template is literally easier to see.

Prototypes are beautiful: digitally averaged birds, fish, and automobiles were rated more attractive than individual specimens.

For UX, mere exposure supplies the emotional half of the argument for conventions. Jakob’s Law covers the cognitive half: standard patterns are understood faster. Zajonc adds that they’re liked better, since the cart icon and the top-left logo carry decades of accumulated goodwill from billions of exposures.

This stock of goodwill is familiarity capital. Consistency within your product compounds it, because every screen that reuses the same icons, colors, and layout landmarks makes a small deposit.

Designers often have disdain for familiar designs in their eternal quest for originality. But users like the familiar, partly because sleeping in a familiar cave helped them avoid being eaten by cave bears. Oppose millions of years of evolution at your peril.

A redesign, however justified, spends familiarity capital, with the greatest cost falling on your most loyal users. Expectations have two sources: the world’s conventions that newcomers bring and your product’s own history that veterans bring. That’s why redesign complaints come from your best customers, and why “the metrics improved” and “the forums are on fire” are so often both true.

Sometimes the withdrawal is worth it. Budget for it anyway.

A redesign withdraws familiarity capital, and it withdraws most from your most loyal users. Today’s hated version becomes tomorrow’s beloved classic.

Three abuses warrant caution. First, overexposure: the exposure–liking curve is an inverted U, as Bornstein and colleagues showed in 1990. Advertisers call it wear-out; users call your fifth identical upsell banner something unprintable.

Rotate and space promotional creative. Repetition can build affection for a brand, but an unchanged banner breeds the proverbial contempt.

Second, the “users are used to it” excuse: the veteran who runs a 14-step workflow on autopilot demonstrates human resilience. That’s no compliment to the design, which still costs every new hire weeks of training. Measure task performance separately from preference, and let performance overrule fondness. Familiar garbage is still garbage.

A veteran running a 14-step workflow on autopilot demonstrates human resilience. Familiar garbage is still garbage.

Third, misreading A/B tests: change aversion can make a better redesign lose in its first week just because it’s unfamiliar, while a mediocre incumbent’s satisfaction scores remain inflated by years of exposure. Run redesign experiments for 2–4 weeks, and judge the trend line rather than the opening snapshot.

AI Model Swap = Invisible Redesign

Mere exposure helps explain AI’s adoption speed. The chat thread arrived pre-liked by years of texting, which let an alien technology ride into town on one of the most familiar interaction patterns on Earth.

But AI products have found a new way to torch familiarity capital: changing behavior without changing pixels. Swap the underlying model, and tone, verbosity, and refusal patterns can shift overnight while the interface looks identical. Users experience these changes as a redesign. When users protest that an AI product “got worse” after an upgrade, some may be reacting to a changed personality rather than a decline in quality. OpenAI learned this in August 2025, when it replaced GPT-4o with GPT-5 and users revolted. Within 3 days, the old model was back, and Sam Altman admitted that OpenAI had underestimated how much the things people liked in GPT-4o mattered to them, “even if GPT-5 performs better in most ways.”

Swap the underlying AI model, and tone, verbosity, and refusal patterns shift overnight while the interface looks identical. Users experience a redesign even though the pixels stay put.

The remedies follow classic redesign practice: announce model changes, roll them out gradually, keep the old model available during a transition, and hold the product’s tone and persona stable across upgrades. Exposure also compounds at AI speed: patterns like streaming text and “thinking” indicators went from novel to expected within roughly 2 years, because daily AI use exposes people to them far more often than occasional website visits do.

The MAYA Principle: Design to the Edge of Familiarity, Never Past It

Definition: The MAYA principle (Most Advanced Yet Acceptable) states that a design should be as advanced as possible while remaining acceptable to its intended users. It must be recognizable enough that users can map it onto what they already know.

Raymond Loewy (1893–1986), the French-born American designer often dubbed the father of industrial design, put his mark on much of the 20th century: the Lucky Strike pack, the slenderized Coca-Cola bottle, the Greyhound bus, the Shell logo, the S-1 locomotive, and the interiors of NASA’s Skylab (biography). He presented MAYA, his own acronym, in his 1951 autobiography Never Leave Well Enough Alone. He argued that the public rejects solutions representing “too vast a departure” from the norms it has been conditioned to accept.

Loewy saw consumers torn between attraction to the new (neophilia) and fear of it (neophobia). Products win by resolving that tension: bold enough to excite, familiar enough to operate. His locomotives looked like the future, and their controls sat where the engineer’s hands expected them. That combination sold.

For 52 years, MAYA remained a brilliant practitioner’s hunch. Then Paul Hekkert of Delft University of Technology and his co-authors tested it in three studies of consumer products (British Journal of Psychology, 2003). Typicality and novelty jointly predicted aesthetic preference, and people preferred novel designs as long as the novelty didn’t undermine typicality. The results vindicated Loewy.

I think of each release as spending from a novelty budget. Users will absorb only so much unfamiliarity before they balk, so spend the budget on changes that pay off, and keep the rest of the design reassuringly boring.

Each release spends from a novelty budget. Spend it on changes that pay users back in capability, and skip the decorative rebellion.

Teams botch the budget in two opposite ways. Failure mode 1 is cowardice: quoting “yet acceptable” while forgetting “most advanced,” cloning the competition, and adding another product to the sea of sameness.

Hekkert’s findings place peak preference below maximum typicality, so a design that feels entirely familiar misses the sweet spot. The ambition comes first in the acronym for a reason. Failure mode 2 is shock therapy: advancing everything at once.

The remedies: advance one dimension per release while keeping the layout skeleton, core icons, and entry points in place. Keep a classic mode during transitions. Test acceptability with mainstream users rather than early adopters, who live beyond the frontier and will cheerfully wave you off a cliff. Re-survey the frontier regularly, because it keeps moving.

Test acceptability with mainstream users rather than early adopters, who live beyond the frontier and will cheerfully wave you off a cliff.

What was “too advanced” in 2007 is the baseline in 2026. Back then, typing on glass struck BlackBerry loyalists as a step too far. Today, physical phone keyboards are museum pieces.

Two special species of convention round out the picture. A bridge convention is a familiar handle bolted onto a new mechanism to carry users across. The stitched leather and wooden bookshelves of early iOS escorted a generation into multitouch. Once the crossing was complete, Apple dismantled the bridge with the flat design of iOS 7 in 2013.

Bridges are scaffolding; the mistake is leaving them up until they become the building.

A bridge convention is a familiar handle bolted onto a new mechanism to carry users across. Bridges are scaffolding; the mistake is leaving them up until they become the building.

A fossil signifier is the opposite case: the referent died, and the sign lives on. The floppy disk still means Save to users who have never touched one.

Fossils prove that exposure alone can keep a convention alive long after its original analogy has died. Replacing a working fossil with a “more logical” icon withdraws familiarity capital and makes users learn a new sign.

A fossil signifier outlives its referent: the floppy disk still means Save to users who have never touched one. Don’t replace a fossil that still works.

AI Needs Familiar Handles on Radical Machinery

Chat may be the greatest MAYA move in software history. The most advanced technology of the decade reached a billion people through the humble text-message thread, much as the iPhone’s bridge conventions helped introduce multitouch. But AI bends MAYA’s clock: capability can now outrun acceptability in months rather than years. The more advanced the machinery becomes, the more familiar its handles need to be.

Agentic AI now faces the same test. Few users have a schema for an “autonomous software colleague,” so successful agent UIs will borrow ones already installed in users’ minds: the inbox where agent results await review, the draft standing by for approval, the brief you’d hand a new coworker, and the to-do list somebody else completes.

Meanwhile, cowardice is rampant in AI too. A sea of 10,000 indistinguishable chat boxes is hardly a triumph of innovation. A chat-only interface often leaves the novelty budget unspent, since plenty of tasks beg for a GUI’s visible options, direct manipulation, and previews. Chat won the first round on familiarity. My prediction: hybrids that show intent, options, and consequences will win the second.

Hybrids face a trap of their own as the industry moves toward generative UI, where AI constructs custom controls and layouts on the fly for each task. Naive personalization collides with the expectation economy. If an interface morphs its layout every time the user’s intent shifts, where does muscle memory live?

A UI that reinvents itself on every turn levies a continuous adaptation tax. Users never get enough repetitions to build familiarity, so they stay stuck in Fitts and Posner’s slow cognitive stage, like tourists in a city whose streets rearrange themselves every night.

A generative UI that reinvents itself on every turn levies a continuous adaptation tax, and muscle memory has nowhere to live.

The remedy is constitutional UI: an invariant skeleton around a generative canvas. Lock down the structural grammar, navigation landmarks, undo controls, and permission chrome so they stay put. Then let AI generate bespoke interactive widgets inside the task viewport. Tailor the task workspace, but keep the landmarks users reach for predictably boring.

In AI, re-survey the acceptability frontier quarterly. A MAYA verdict from last year has probably passed its expiration date.

Conclusion: Expectations Are the Only Interface Users Ever See

The 7 research traditions converge on one conclusion, backed by a century of evidence: people perceive, judge, remember, and form preferences through templates built from prior experience. Human brains won’t get a firmware update anytime soon, so expect this pattern to hold.

From Thorndike’s transfer of learning in 1901 to today’s AI, a century of research keeps converging on the same result.

In 1932, Bartlett’s British readers turned canoes into boats. Today, your users turn your inventive checkout into the standard checkout they remember. They approach your product with expectations already in place, and the more closely its behavior matches those expectations, the better its usability, its conversion rate, and even its perceived beauty.

Modern cognitive science has sharpened the old lesson. The philosopher Andy Clark (Surfing Uncertainty, 2016) and other proponents of predictive processing hold that the brain is a prediction machine that continually guesses what comes next and spends its attention mainly where the world contradicts those guesses.

The brain is a prediction machine: confirmed guesses feel effortless, and failed ones grab attention.

In that light, all 7 principles share a common thread. Schemata (individual) and conventions (collective) supply the predictions. Astonishment follows a prediction error, which seizes attention and pulls it away from the user’s task. And confirmed predictions create fluency, making designs easier and more pleasurable to use, because users can anticipate how the design will respond.

The expectation economy keeps 4 ledgers. Borrow conventions, and you import training other companies paid for. Bank consistency, and familiarity capital compounds into liking.

The expectation economy keeps 4 ledgers: borrowed conventions, banked consistency, the surprise tax, and the novelty budget.

Violate an expectation, and users pay a surprise tax every time it catches them off guard. Innovate, and you spend from a novelty budget, which should fund capabilities that repay users rather than decorative rebellion.

AI changes the size of the entries in these ledgers. Conventions form faster, surprises cost more when agents act instead of merely talking, and the novelty budget burns faster.

That leaves one strategic puzzle for business leaders: if you obey Jakob’s Law and match every industry convention, don’t you also reduce your customers’ switching costs? At the level of individual controls, the answer is yes.

A user who masters your checkout or prompt box in 3 seconds can master your competitor’s just as quickly. But trapping users with idiosyncratic UI controls is a self-defeating answer, because the same weirdness that locks in existing customers repels new ones.

Instead, separate public interaction conventions from private context equity. Keep controls conventional so anybody can walk in and operate the product immediately. Build your competitive moat out of accumulated state, verified workflows, project history, and learned user preferences. Let competitors help train your users’ hands, and make your product the place that already knows their work.

Trapping users with idiosyncratic controls is a poor moat, because it makes your own onboarding harder. Keep interaction conventions public, and build the moat from private context equity.

Interfaces should look like what they are, behave like what they resemble, and change no faster than their users’ templates can follow. Users bring their own interface to every product they touch. Yours will be judged by how gracefully it fits the one they already carry in their heads.

37 Design Guidelines for Meeting User Expectations

Each of these 7 principles usually gets its own little list of tips. Usability doesn’t work in silos, so here’s one consolidated list instead: the whole expectation economy in 37 guidelines.

Follow the conventions users already know:

1.          Inventory your genre’s conventions before designing. Review the top 5 competitors and the platform guidelines, and use their common patterns as the starting point for layout decisions.

2.          Put controls where history trained users to look. Place the logo at the top left and link it to the homepage, place search near the top and the cart at the top right, and put the primary action where the platform’s dialogs put it.

3.          Use standard widgets for standard jobs. A link should look like a link, a button like a button, and an input field like something that accepts input. Disguised controls are invisible controls.

4.          Match genre prototypes on critical pages. Checkout, login, search, and pricing pages are the wrong place for visual experimentation, because users arrive with well-established expectations of how to complete these tasks.

5.          Never ship a near-convention. A control that looks standard but behaves differently triggers a habit and then betrays it. When you must depart from a convention, depart visibly so that the novelty announces itself before the click.

Dress the interface honestly:

6.          Make every label tell the literal truth. A control should do exactly what its name says: “Cancel” must never mean “continue,” and a toggle’s actual effect must match its caption.

7.          Same action, same result, everywhere. A gesture or command should carry one meaning throughout your product, so users can transfer what they’ve learned from one screen to the next.

8.          Reserve interrupting confirmations for anomalous or high-stakes actions. Repeated confirmation dialogs breed blind clicking as habits take over. Let routine, reversible actions run with one-click undo, and save attention-demanding previews for actions whose stakes or unusual circumstances warrant jolting the user awake.

9.          Never dress one element in another’s schema. Don’t style ads as content, promotions as system dialogs, or sponsored results as organic listings. Label paid content clearly enough that users can recognize it at a glance.

10.      Invest visual polish where trust gets decided. When people judge visual appeal within 50 milliseconds and base many credibility judgments on appearance, an amateur-looking payment page is a self-inflicted wound.

Help users build the right mental model:

11.      Make the conceptual model visible. Show the system’s current state, where users’ data lives, and what each action will do. These cues help users build a mental model that matches reality.

12.      Give feedback that reinforces the correct model. Clear responses to users’ actions teach them how the system behaves and can correct mistaken assumptions before they cause harm.

13.      Provide feedforward before consequential actions. Before an irreversible or expensive step, show what will happen in the user’s terms: which files will change, which recipients will be contacted, or which charge will be made. A label says what a control does; feedforward says what it will do this time.

14.      Fix mental-model mismatches by changing the design first. Matching the model users already hold is usually easier than teaching them a new one, not least because most users skip onboarding instructions.

15.      Bridge novelty with familiar schemata. When you must introduce a concept users have never encountered, give them a familiar anchor instead of inventing vocabulary from scratch.

Test against users’ expectations, not your own:

16.      Remember that you are not the user, and test with mainstream users as well as early adopters. After 6 months on a project, little in your product can astonish you. Teammates and tech enthusiasts also live far past the acceptability frontier of mainstream users.

17.      Watch 5 users and treat confusion as data. When 2 of 5 hesitate at the same control, you’ve found evidence of an expectation violation. The flinch is the bug report.

18.      Recruit by behavior, and size samples to the claim. Resemblance to a persona proves little about how someone uses a product. A test with 5 users can uncover usability problems; measuring conversion often requires thousands.

19.      Measure performance and preference separately. Exposure can boost preference even when a design remains hard to use, so let task-performance numbers overrule fondness.

20.      Run redesign A/B tests for 2–4 weeks, and judge the trend line. Change aversion can punish a better design in its first week, while an incumbent enjoys satisfaction scores inflated by familiarity.

21.      Never cite habituation in defense of bad design. Users can adapt to almost anything, but their resilience doesn’t excuse the time and effort a poor design demands.

Manage change like the withdrawal it is:

22.      Lock down load-bearing landmarks across redesigns. Stable logo placement, navigation, core gestures, and primary workflows let users carry accumulated familiarity and skills into the new version.

23.      Compete on accumulated context, not idiosyncratic controls. Keep controls conventional so newcomers can get started quickly, and build retention through saved state, workflows, and learned user preferences.

24.      Prefer a series of small changes to a grand unveiling. Advance one dimension at a time (a new capability, visual language, or interaction model), so users can absorb increments rather than upheaval.

Prefer a series of small changes to a grand unveiling. Change everything at once, and even your most loyal users won’t recognize you.

25.      Upgrade legacy search and forms for AI-trained expectations. Users accustomed to conversational systems expect other websites to tolerate messy intent as well. Rigid keyword-only search and unforgiving input masks collect a retroactive surprise tax.

26.      Keep a classic path during transitions. Give users time to learn the new version, and let them opt into the future instead of being deported to it.

27.      Dismantle bridge conventions once users have crossed, but keep fossil signifiers that still work. A transitional metaphor is scaffolding to remove once the new model has taken hold. An icon users already know is capital: don’t swap it for one they’ll have to decode.

28.      When innovation requires astonishment, stage it. Announce the change, show a preview, keep the old behavior as the initial default, and put undo one click away so users can recover if the change catches them off guard.

29.      Break a convention only when the departure delivers core value, and test it with 5 users first. If participants hesitate or misread the control, the schema debt may exceed the novelty dividend.

30.      Refuse pure cloning. If nothing in your design tests as new, you may have underspent the novelty budget and forfeited the “most advanced” half of MAYA.

A sea of indistinguishable chat boxes is hardly a triumph of innovation. If nothing in your design tests as new, you’ve underspent the novelty budget.

31.      Reassess the acceptability frontier yearly, and quarterly for AI. Yesterday’s “too advanced” can become today’s expectation, so an old MAYA verdict has a short shelf life.

Design AI to earn the expectations it inherits:

32.      Wrap generative UI inside an invariant skeleton. When AI generates task controls on the fly, keep navigation landmarks, permission controls, and undo in fixed positions so adaptive views don’t destroy users’ spatial memory.

Constitutional UI: let AI generate the scenery inside the task viewport, but keep navigation landmarks, undo, and permission controls fixed in place.

33.      Adopt emerging AI conventions instead of inventing rivals. Users transfer expectations about prompt boxes, streaming replies, stop buttons, and visible conversation history from market leaders to your product, whether you like it or not.

34.      Give the prompt box signifiers. Example prompts, suggestion chips, capability menus, and structured forms tell users what the AI can do. An empty rectangle tells them nothing and leaves low-articulation users stranded.

The best AI products are rediscovering the button: example prompts, suggestion chips, and capability menus tell users what the AI can do.

35.      Calibrate the AI’s costume. Pair fluent output with sources, uncertainty markers, and ways to verify claims, so users can tell eloquence from accuracy.

36.      Give agents previews, permission tiers, activity logs, and undo. An agent should propose before it acts, log what it did, and make reversal easy. Let it earn greater autonomy in steps instead of granting it wholesale through a settings page.

An agent without state signifiers becomes unaccountable, however magical it may feel. Give agents visible status, activity logs, and undo.

37.      Treat a model change as a redesign. Announce it, stage the rollout, keep the previous model available during a transition, and hold tone and persona stable. Behavior is part of the interface, even when the pixels don’t move.

Follow the first 31, and you’ll profit from the training users bring from the rest of the world. Follow the last 6, and your AI product can collect on that same accumulated experience. Expectations arrive with the user either way. Your design can cash them in or fight them.

Pilots run a checklist before every takeoff. Run this one before every release.