UX & Interaction

Busted

• AffordanceWhat a thing actually lets you do. The visible cue advertising it is a signifier: raised means press, a grip means drag.
• Autosave with save indicatorNo save button: edits persist on their own, and a small label tells you whether the work is actually safe.
• Banner blindnessThe learned habit of skipping page regions that look like ads, even when the message inside is useful.
• Bulk actions / multi-selectCheckboxes on rows plus a toolbar that appears once you pick some, so one click applies an action to fifty things instead of one.
• Cancellation / interruptibilityA real way to stop an upload, export, generation, or other long task before it finishes, with a clear account of what already happened.
• Change blindnessThe interface changed, but the user never noticed because their attention was somewhere else when it happened.
• Cognitive loadThe amount of thinking an interaction demands, especially remembering facts, decoding controls, and choosing among competing options.
• Consistency and standardsMaking the same words, controls, and actions behave the same everywhere, while respecting conventions people already know.
• Contextual / just-in-time helpHelp delivered at the exact spot and second someone needs it, instead of in docs they will never open.
• Conversational UICompleting a task as a back-and-forth conversation, with the interface confirming what it understood at each step.
• Destructive-action confirmationA deliberate speed bump before something irreversible: an are-you-sure step, or typing the name of the thing to delete.
• Direct manipulationActing on the visible thing itself, like dragging a card or resizing a box, instead of describing the change through commands.
• Dirty state / unsaved-changes guardThe app knows you have edits you never saved, so it warns you before you navigate away and lose them.
• DiscoverabilityHow likely someone is to find out a feature exists at all, without being told. Shipped but hidden equals not shipped.
• Drag-and-drop with drop targetPicking an item up with the pointer while the interface shows exactly where it can land: a highlighted zone, an opening gap, a line.
• Empty, error, and loading statesThe three screens every view needs besides the happy one: nothing yet, still fetching, and something broke.
• Error preventionRemoving chances to make a mistake before it happens, instead of accepting the bad action and explaining the damage afterward.
• Error recoveryWhat your UI does after something fails: keep the user's work, say what broke in plain words, offer one obvious way forward.
• Escape hatchEvery flow, mode, and dialog needs an obvious way out that costs the user nothing. The clearly marked exit.
• FeedforwardA preview or cue shown before you act that answers, 'What will this do?' instead of waiting until afterward to explain.
• Fitts's lawBigger and closer targets are faster to hit. The math behind large buttons, edge menus, and 44px tap targets.
• Forgiving formatAccept input in whatever shape people type it, then quietly clean it up, instead of rejecting it over spaces and dashes.
• Gestural affordance / peekPartly revealing the next card, panel, or row action so the visible edge hints that you can swipe or drag.
• Guardrails / constrained inputShaping the input so invalid answers are impossible to enter, instead of accepting garbage and scolding the user afterwards.
• Happy path / edge caseThe happy path is the run where everything works. Edge cases are the boundary runs: empty, huge, expired, duplicated, weirdly shaped.
• Haptic feedbackA brief physical tap or vibration from the device that confirms an action, marks a boundary, or signals success or failure.
• Hick's lawDecision time generally grows as unfamiliar, similarly weighted choices pile up. Long flat menus feel slow for a reason.
• Hover intentA short pause before hover UI reacts, so crossing the screen does not spray open menus and previews.
• Infinite scroll vs paginationTwo ways to end a long list: keep appending as the user scrolls, or split it into numbered pages you can link to and come back to.
• Information scentHow clearly a link or label signals what you will find after clicking it. Strong scent makes the next move feel obvious.
• Inline validationChecking one field at a time and showing the problem right beside it, instead of dumping a list of errors after submit.
• Mental modelThe picture in a user's head of how your product works. Match it and things feel obvious; miss it and everything feels broken.
• MicrointeractionThe tiny contained moment around a single action: the toggle that slides, the heart that pops, the button that confirms it heard you.
• Modal vs modelessThe choice between a surface that blocks the rest of the app until it closes and one that stays open while you keep working.
• Mode errorA mistake caused by doing the right action in the wrong interface mode, like typing with Caps Lock on or drawing with the wrong tool active.
• Multi-step wizardA long form split into numbered Next and Back steps, with each chunk checked before the person moves on.
• Natural mappingArranging controls so their position, direction, or order clearly matches what they change, like a stove control beside its burner.
• Nudges and frictionChoice design with a thumb on the scale: make a helpful action easier, or add a pause before a costly mistake.
• Onboarding flowThe guided first run that takes someone from fresh signup to their first real win, instead of an empty app.
• Optimistic rollbackWhen the server rejects the change you already showed as done, the UI puts the old state back and tells you why.
• Optimistic UIUpdating the screen the instant someone acts, before the server confirms anything, then quietly putting it back if the request fails.
• Product tourThe first-use sequence of callout bubbles that points at real controls and walks someone through one useful task.
• Progressive disclosureShowing the few options most people need and tucking the rest behind an 'Advanced' toggle they open only when they need it.
• Pull-to-refreshDragging past the top of a touch list to reload it, with resistance and a release threshold that prevent accidental refreshes.
• Recognition over recallPut the options on screen instead of making people remember them. Picking from a list beats typing from memory.
• Scroll restorationPressing Back returns you to the exact part of the list or page you left, instead of dumping you at the top.
• SignifierThe visible or audible clue that says where an action is and how to use it, like an underline, button shape, label, or drag grip.
• Slip vs mistakeA slip is doing the wrong action despite the right goal; a mistake is choosing the wrong goal or plan in the first place.
• Smart defaultsPre-fill the choice most people want so the common case takes zero clicks, while anyone can still change it.
• State persistenceKeeping what someone typed, selected, or opened so a refresh, Back click, or interruption does not make them start over.
• Undoable actionInstead of asking 'are you sure?', do the thing and offer an undo. Reversal beats confirmation for almost everything.
• User control and freedomGiving people a clear way to cancel, go back, close, or undo so one wrong click never traps them in a flow or permanent result.
• User flow / task flowThe ordered screens, decisions, and clicks a user moves through to finish one goal, like 'sign up' or 'refund an order'.
• Visibility of system statusNielsen's first usability heuristic: the interface always tells you what it is doing right now, soon enough to be useful.

The territory

30 core terms mapped for this field, ranked by how often builders reach for them. Each one is a future entry. Want to bust one? One entry, one file, one pull request.

• Optimistic UIShow the result instantly, reconcile with the server after"act like it worked already" · "instant even though it's still saving"
• Empty, error, and loading statesThe three non-happy screen states every view needs"the nothing-here screen" · "empty state"
• Visibility of system statusTelling the user what's happening right now"show it's actually doing something" · "feedback loop"
• Inline validationField-level errors shown as the user types or blurs"tell them the email is wrong before they submit" · "errors while you type"
• AffordanceVisual cue that signals how an element can be used"it looks clickable" · "the thing that tells you you can drag it"
• Progressive disclosureReveal advanced options only when the user needs them"hide the complicated stuff until asked" · "show more as you go"
• Undoable actionReversible action offered instead of a confirm dialog"let them take it back instead of asking" · "the little undo bar"
• Error recoveryKeep the user productive when something fails"what it does when it breaks" · "how they get unstuck"
• Mental modelThe user's assumed picture of how the system works"what they expect it to do" · "how they think it works"
• User flow / task flowThe step-by-step route a user takes to a goal"the screens in order" · "the click path"
• Happy path / edge caseThe intended flow versus everything that deviates"when everything goes right" · "the weird cases"
• DiscoverabilityHow easily users find a feature exists at all"nobody knows that button is there" · "people can't find it"
• Recognition over recallShow options rather than making users remember them"don't make them memorize it" · "let them pick from a list"
• Guardrails / constrained inputPreventing invalid states instead of validating after"stop them entering something wrong" · "grey out what they can't pick"
• Escape hatchAlways-available way out of a flow or mode"a way to back out" · "let them bail"
• Smart defaultsPre-fill the most likely choice"pick the sensible option for them" · "pre-filled fields"
• Forgiving formatAccept messy input and normalize it silently"let them type it however they want" · "clean up what they typed"
• Focus managementDeliberately moving keyboard focus after an interaction"where the cursor goes after the modal opens" · "what's selected next"
• Destructive-action confirmationFriction gate before irreversible operations"type DELETE to confirm" · "are-you-sure step"
• Dirty state / unsaved-changes guardWarn before leaving with unsaved edits"are you sure you want to leave" · "don't lose my work"
• Autosave with save indicatorContinuous persistence plus a visible "saved" cue"saves as you type" · "the little saved checkmark"
• Optimistic rollbackReverting the UI when the server rejects the assumed result"put it back if the save fails" · "undo it when the server says no"
• Onboarding flowGuided first-run sequence that gets a user to value"the setup wizard on signup" · "the first-time walkthrough"
• Contextual / just-in-time helpAssistance shown at the moment of need"the little ? next to the field" · "help right where you need it"
• Fitts's lawBigger and closer targets are faster to hit"make the button bigger" · "why tiny buttons are hard to click"
• Hick's lawMore choices means slower decisions"too many options slows people down" · "fewer choices is faster"
• MicrointeractionTiny feedback moment on a single action"the little reaction when you tap" · "micro-interaction"
• Infinite scroll vs paginationContinuous loading versus discrete numbered pages"keeps loading as you scroll" · "page 1, 2, 3 at the bottom"
• Bulk actions / multi-selectOperate on many rows at once via checkboxes"select all and delete" · "tick the boxes and act"
• Drag-and-drop with drop targetPicking up an item and showing where it can land"the highlighted slot where it'll go" · "drag it into place"

Deeper in the field

• Direct manipulation Manipulate visible objects directly instead of issuing abstract commands
• Signifier Perceptible cue showing where or how a user can act
• Feedforward Show what an action will do before the user commits
• Error prevention Design out avoidable errors instead of validating after the fact
• User control and freedom Let users cancel, back out, and reverse actions
• Consistency and standards Similar actions behave predictably across the whole interface
• Cognitive load Mental effort required to understand and complete an interaction
• Natural mapping Controls correspond clearly to the effects they produce
• Mode error Mistake caused by acting while the interface is in another mode
• Slip vs mistake Execution error versus choosing the wrong goal or plan
• Change blindness Users fail to notice an interface change after acting
• Cancellation / interruptibility Let users stop a long-running action mid-flight
• State persistence Preserve inputs and selections across navigation or interruption
• Scroll restoration Return the user to their previous position after navigation
• Multi-step wizard Long form broken into sequential validated steps
• Product tour Guided overlay sequence explaining the UI on first use
• Information scent How strongly a link predicts what's behind it
• Modal vs modeless Blocking the app versus letting work continue
• Nudges and friction Deliberately easing or slowing a specific behavior
• Banner blindness Users ignore anything shaped like an ad
• Hover intent Delay before reacting so passing the cursor doesn't trigger
• Pull-to-refresh Drag past the top of a list to reload
• Gestural affordance / peek Partially revealing content to hint at a swipe
• Haptic feedback Physical vibration confirming an action
• Conversational UI Chat-driven task completion with confirmations along the way