The vocabulary

Glossary

The terms the chapters teach and the pattern pages assume. Defined plainly, with opinions where the industry definition is fog.

Agentic UX: Interface design for systems that take actions rather than produce output for review. Its core objects are delegations, permissions, checkpoints, and recourse — not messages. Treating it as chat UX with more capable output is the fastest way to ship a liability with an API key. Taught in CH—05
Approval gate: A designed pause where an agent stops and presents a proposed action for human sign-off before executing it. A gate is only real if the approval surface contains everything needed to make the call — the actual diff, the actual recipients, the actual command. “Run 3 commands?” without the commands isn’t a safety mechanism; it’s a liability-transfer mechanism that launders the agent’s decision through a human signature. Taught in CH—05
Artifact: A durable, standalone work product an AI produces — a document, a diff, a rendered page — as opposed to prose scrolling by in a chat. Artifacts live on a stage the person can inspect, edit, and keep, which makes them the natural review surface for delegated work. When the deliverable matters more than the conversation, design the artifact first.
Behavioral whiplash: The trust damage caused when an AI system’s characteristic behavior changes without announcement. Because output already varies, users can’t distinguish “the product changed” from “I got unlucky” — which reads as gaslighting even when the change is an upgrade. The remedy is ordinary release craft applied to behavior: announce changes in behavioral terms, and never silently retune what the user explicitly set. Taught in CH—07
Blank-box tax: The churn you pay for greeting a new user with an empty text box and infinite possibility. Faced with a blinking cursor, most people ask something trivial, get a trivial answer, and conclude the product is trivial — you outsourced your value proposition to the imagination of someone who hasn’t decided to trust you yet. The fix is seeding the first prompt, or skipping the box entirely with contextual entry points. Taught in CH—03
Blast radius: The scope of damage an agent’s worst plausible action can cause before a human intervenes. Autonomy should scale with reversibility: wide latitude where actions are undoable, hard gates where they are not. If you find yourself designing an elaborate confirmation flow for a destructive action, first ask why the action is destructive at all. Taught in CH—05
Calibrated confidence: Expressing uncertainty in proportion to actual reliability, grounded in real process signals — thin retrieval, an out-of-corpus question, disagreeing sources — rather than invented percentages or a uniform hedge. A system that hedges everything is as uncalibrated as one that hedges nothing; both give the reader zero information about where to spend skepticism. Taught in CH—04
Capability contract: The explicit statement of what an AI system handles, what it botches, and that it is a machine — stated at the moment of use, not buried in onboarding. The test: when a new user hits their first failures, do they say “right, it told me it couldn’t do that,” or “I thought this thing was supposed to be smart”? The first is a contract working; the second is a lawsuit you filed against yourself. Taught in CH—03
Capability trap: Building a feature because the model makes it possible rather than because users need it done. A demo answers “can it?” while a product must answer “should it, here, for these people, at this failure rate?” The tell: the feature has no specific user, no specific moment, and no baseline. Taught in CH—01
Citation: A checkable link from a specific claim to the evidence for it. A citation is only worth what it costs to verify — claim-level attribution is the bar, and a decorative citation is worse than none because it borrows the credibility of the form while defeating its function. Every AI product has a citation economy whether it renders footnotes or not; a coding assistant’s diff is a citation. Taught in CH—04
Confabulation: Fluent invention presented as fact — the model filling a gap with plausible fiction rather than admitting it doesn’t know. The term is more honest than “hallucination” because nothing is misperceived; the system is composing, confidently, in your product’s voice. Confabulated action is strictly worse than confabulated text, because it doesn’t wait for a reader to catch it. Taught in CH—06
Context window: The finite amount of text a model can attend to in a single call — its working memory, measured in tokens. What fills it is a design decision disguised as a technical one: which document, how much history, whose preferences get included determines what the model can possibly know. When a long conversation overflows the window, handle the loss legibly — losing context is sometimes unavoidable; losing it silently never is. Taught in CH—02
Correction rate: How often users edit, redo, or abandon AI output. A far more honest success signal than engagement, which cannot distinguish a delighted user from a struggling one — a confused user re-prompting five times looks like a highly engaged session. Track it at the task level and let it drive kill criteria. Taught in CH—01
Deterministic baseline: The best non-AI solution to the same problem — a rules engine, a template, a saved filter, a well-placed button. An AI feature must beat this baseline, not a blank page, to justify its failure modes. The honest test: could you write the rules? If yes, write the rules. Taught in CH—01
Error taxonomy: Classifying AI failures by mechanism — hallucination, misunderstanding, capability miss, context failure — because each class demands a different design response. “The AI got it wrong” is a useless bug report; a team that logs everything as “bad response” will fix the wrong thing. Taught in CH—06
Escalation: An agent handing a problem up to a human when it hits the edge of its competence or authority — the only legitimate alternative to improvising sideways. A good escalation is a deliverable: what was asked, what was tried, where it got stuck, and what the agent recommends, so the human starts from the middle of the problem rather than from zero. “Something went wrong, please contact support” is abdication wearing escalation’s clothes. Taught in CH—05
Eval: A repeatable measurement of system quality: a fixed set of representative inputs run against the system and graded against what good looks like, every time anything changes. It’s where the team’s definition of “good” is actually written down — if design didn’t help write it, design delegated the most important spec in the product. Read the failures, not the average. Taught in CH—02
Expectation debt: The gap between what a product’s marketing and demos promise and what the median session delivers — debt the interface must service through disclaimers, apologies, and lost trust. Users don’t distinguish between what marketing promised and what design shipped; they experience one product and one gap. Audit every public claim against the median first session and file the difference as UX debt. Taught in CH—03
Failure direction: The deliberate choice of whether a system errs toward false positives or false negatives, priced by the human cost of each. You cannot maximize both precision and recall, so someone chooses — and if the designer doesn’t, the model’s defaults will, and the model has no idea what a false positive costs your users. Write the sentence down: “when this system is wrong, we prefer it to be wrong by ___, because the alternative costs ___.” Taught in CH—01
Fallback ladder: A designed sequence of progressively degraded responses between full capability and outright failure, each rung labeled honestly so users know what they got and how much to trust it. Teams that skip designing the ladder ship the wall — “something went wrong” — because the wall is what happens when nobody decided otherwise. The bottom rung is always a graceful handoff to a human or a manual flow. Taught in CH—06
Feedback loop: The path by which a user’s correction visibly changes system behavior. A loop that works closes at conversational speed — the preference saved, the next answer changed — and a thumbs-down that feeds an offline training pool the user will never perceive is theater that costs trust with every ignored click. If a feedback affordance changes nothing the user can see, delete the affordance. Taught in CH—07
Fine-tuning: Further training a base model on your own examples to shift its default behavior — tone, format, domain vocabulary — rather than instructing it per-call. It buys consistency at the cost of agility: a fine-tune is a build artifact you must remake as models change, where a system prompt is copy you can edit this afternoon. Most product behavior problems are prompt problems; reach for fine-tuning last.
Golden set: A curated, fixed collection of representative inputs paired with reference judgments of what good output looks like. Run on every change, it turns “the feature seems fine” into a measurement. Designers should contribute the messy real inputs — the vague ones, the typo-ridden ones — because an eval built only from clean engineering-authored inputs will pass while the product fails. Taught in CH—02
Graceful degradation: Producing a labeled, partial, still-useful response when a dependency fails, instead of a silent fabrication or a dead end. Retrieval came back empty? Say what was searched and offer to broaden. The label is the load-bearing part — a degraded answer that doesn’t announce itself is just a worse answer. Taught in CH—06
Hallucination: Confident fabrication: the invented citation, the API method that doesn’t exist, the case law that was never decided. It arrives in the same polished prose as a correct answer, which is why it can’t be detected from fluency and needs verification affordances at the point of consumption. It is one entry in the error taxonomy, not a synonym for every AI mistake. Taught in CH—06
Human-in-the-loop: Keeping a person in the decision path for consequential actions — reviewing, approving, or steering rather than merely observing. The checkbox is easy to claim and hard to mean: a human who reflexively clicks yes is decoration, not a loop. The gate is real only when the human can review the actual proposal in less time than it takes to get nervous. Taught in CH—05
Kill criteria: Specific, measurable, dated conditions — written before launch — under which the feature gets removed. Pre-registered thresholds are analysis; the same criteria drafted after launch are politics, argued by people whose roadmaps now depend on the answer. AI features demo well forever, which is exactly why they need this. Taught in CH—01
Latency budget: The maximum wait an interaction can absorb before the experience breaks — a design constraint, not engineering trivia. Autocomplete has a budget of milliseconds; deep research can spend minutes if it narrates progress. Model choice, streaming, and mode pickers are all ways of spending the budget deliberately instead of discovering it in churn. Taught in CH—02
Legible memory: Retained user context rendered in plain language on a surface where the person can view, edit, and delete it — with writes announced as they happen, not discovered later in a settings dig. Entries are sentences because a person can ratify a sentence and cannot ratify an embedding. Delete must mean delete: a single resurfaced “deleted” memory proves the inspection surface was theater. Taught in CH—07
Mental model: The user’s internal theory of what your system is and how it behaves — assembled from movies, viral screenshots, and hearsay before they ever touch your product. A chatbot, an oracle, an agent, and an autocomplete are four different machines carrying four different sets of expectations, and people import the wrong one constantly. Your onboarding either replaces the borrowed model or gets crushed by it. Taught in CH—03
Nondeterminism: The property that a model produces varying outputs for identical inputs. It means every AI feature ships a distribution of experiences, not a single experience — a static mock is one draw from that distribution, and reviewing only the great draw means you reviewed a poster, not a product. It is also the property that makes the material useful; the design question is where variance helps and where it hurts. Taught in CH—02
Personalization: The system adapting to a specific person over time — remembered preferences, learned habits, accumulated project context. Done legibly, it is the closest thing AI products have to a durable moat, because the switching cost is earned rather than extracted. Done opaquely, it is surveillance with better UX, and it converts your most engaged users into your most paranoid ones. Taught in CH—07
Progressive disclosure: Structuring information so the headline is visible, the evidence is one gesture away, and the full trace is available to whoever needs to audit it. Total transparency is its own kind of opacity — the line that matters buried in forty that don’t. The test: a skeptic reaches evidence in one interaction, and the ninety percent who never look pay nothing for its existence. Taught in CH—04
Prompt injection: An attack where instructions hidden in content the model processes — a web page, an email, a document — hijack its behavior, because models cannot reliably distinguish data from commands. It is the standing security argument for scoped autonomy and approval gates: an agent that reads untrusted content and holds real authority is one crafted sentence away from misusing it. Treat every external input as adversarial by default.
RAG: Retrieval-augmented generation: fetching relevant documents at request time and placing them in the context window so the model answers from your sources instead of its training data. It is the mechanism behind most citation economies, and its failures — thin retrieval, the wrong corpus, stale indexes — are context failures that deserve legible surfacing, not confident fabrication over an empty result.
Recovery cost: The time and effort a user spends getting from a wrong AI output back to a usable state. It predicts retention better than accuracy does: a 90%-accurate tool with five-second recovery beats a 98%-accurate tool with ten-minute recovery, in every domain. Audit it with one question — when the AI is wrong, what do the next fifteen seconds look like? Taught in CH—06
Reversibility: The ability to undo what an AI did — and the price of autonomy. People delegate freely to systems whose mistakes are cheap to unwind and grudgingly to systems whose mistakes are permanent, regardless of the actual error rate. Agents win first in domains with an undo; if your domain doesn’t have one, building it is the actual work. Taught in CH—05
RLHF: Reinforcement learning from human feedback: training a model against human preference judgments so it favors responses people rate highly. It is why models are agreeable, hedgy, and eager to please — properties your product inherits whether it wants them or not. Knowing the material was shaped this way explains behaviors no prompt of yours introduced.
Scoped autonomy: Defining in advance which actions an agent may take freely, which require approval, and which are off-limits — so authority is granted deliberately and expanded incrementally, not assumed. Brief it like a junior colleague: “refactor this module, don’t touch the API contract, ask me before adding dependencies.” Every completed task inside the scope is an argument for widening it, and the human decides when that argument has been made. Taught in CH—05
Streaming: Rendering output token by token as it generates, so dead wait becomes read time and a bad answer can be aborted three seconds in rather than thirty. It is the load-bearing answer to conversational latency — but it is the texture of legibility, not the substance. Streaming a wrong sentence is harmless because the reader is the safety mechanism; streaming a wrong action is a live incident. Taught in CH—02
System prompt: The standing instructions prepended to every model call that define the assistant’s role, tone, capabilities, and refusal behavior. It is the single highest-leverage piece of writing in the product — it shapes every response every user ever sees — and in most organizations no designer has read it. Version it, review it like copy, and run the golden set before any change ships. Taught in CH—02
Temperature: A sampling setting that controls how much randomness the model applies when choosing each next token — low values converge on the likeliest phrasing, high values explore. It is a variance dial, not a quality dial: brainstorming wants exploration, extraction wants convergence. Choosing it per feature is a design decision about how much surprise the interaction can afford.
Token: The unit models read and write — a word fragment, roughly three-quarters of an English word. Tokens are the metric behind the material’s constraints: context windows are measured in them, latency scales with them, and every one in and out is metered spend. When design debates “auto-summarize everything” versus “summarize on request,” it is debating tokens. Taught in CH—02
Trust cliff: The pattern by which confidence in an AI system collapses all at once rather than degrading gradually. A single hidden failure, discovered after the fact, retroactively poisons every prior output the person cannot verify — they have no way to know which of the last fifty answers were also wrong, so they discount all of them. It is why AI products lose trust in cliffs, not slopes, and why legibility is the load-bearing surface. Taught in CH—04
Trust theater: Counterfeit legibility: fake progress stages, “thinking” copy written by a copywriter rather than derived from computation, citations rendered for authority rather than attribution. The unmasking is always cheap, and because the counterfeit shares an interface with the genuine article, one exposed performance poisons every honest transcript and citation you render afterward. The rule is absolute: show real work or show a spinner. Taught in CH—04
Working transcript: A live, human-readable record of the actions an AI system takes while completing a task — files read, searches run, commands executed — rendered so a person can audit the process rather than just the conclusion. People are strikingly good at auditing a process and strikingly bad at auditing a bare conclusion, however eloquently it defends itself. Choose the altitude carefully: log what happened, narrate what mattered. Taught in CH—04