Patterns for AI products
AIUX is the design of products whose output is generated rather than retrieved. These are the recurring problems that come with that and what actually resolves them: what to do when the model is wrong, which claims the interface should vouch for, when an agent should not be a chat, and how to tell whether a change helped.
Each of the 40 patterns is grounded in something shipped — a product in the case studies on this site, or a count taken from the system behind them — rather than read off someone else’s release notes. It is a working vocabulary, not a survey, so it grows when a project teaches something and not otherwise.
Jump to
Foundations
The primitives that exist only because the output is generated — what streaming costs you, what carries the wait, and what a second attempt actually produces.
- 07
Streaming is a commitment
Streaming buys perceived speed and spends revisability — once a sentence has been on screen it has been read, so anything you would want to check has to pass before the first token.
streaming · latency · chat
- 08
The character is a state machine
An AI persona is not a logo — it stands in for a process with no other visible tell, so it needs states, and the version that survives is one rig those states are paths through.
persona · identity · motion
- 09
Show the machine listening
Continuous capture has no natural edges, so the interface has to show three states continuously — not listening, listening and hearing nothing, listening and hearing you — from the signal itself rather than a timer.
voice · input · liveness
- 10
Regeneration is an edit, not a retry
Retry means the same result in deterministic software and a different one here, so a second attempt is a branch — the interface owes an answer to what is kept and what became of the other one.
regeneration · versions · recovery
Interaction model
How the product presents what it can do, and the shape the interaction takes once someone accepts.
- 01
Wizard or conversation
Choose a conversation only when you can't know the request in advance; otherwise let an agent fill in a structured flow and stop at the review step.
agents · flows · chat
- 27
Capability before the cursor
A text box communicates nothing about what is possible, so a new user cannot calibrate — the product owes a legible range, including its edges, before it offers a cursor.
onboarding · affordances · chat
- 28
Earn the model before you use it
Personalisation has no preference signal on first run — collect it as something worth doing for its own sake, and show the user what it bought before asking for anything else.
onboarding · personalisation · cold start
- 29
Name the actions in the user's verbs
Generative products name their actions after the model's operation — Generate, Summarise, Rewrite — while the user is thinking in the task they came to do.
naming · affordances · agents
- 30
Spend the novelty budget on the model
A product whose core behaviour is unfamiliar cannot also afford unfamiliar chrome — stock components make the new thing the only new thing.
platform · components · familiarity
Agency and oversight
What the product does on someone's behalf, what it does unasked, and who stays answerable for the result.
- 12
Work without being asked
Cheap inference lets a product stop waiting for a prompt, which replaces the question of what it can answer with a harder one — what earns an interruption.
proactive · agents · attention
- 17
Pair every insight with its action
An observation with nothing attached to do about it is a chart — the model made noticing cheap and left acting expensive, which is the wrong way round.
insights · actions · attention
- 20
The reviewer is a role, not a step
Oversight modelled as a dialog at the end of a flow collapses the moment volume arrives — at scale it has to be a standing state on the object, with a named owner and a history.
human in the loop · review · accountability
- 21
Declare the inputs before the run
An agent that discovers what it needs halfway through has already spent the user's patience, and asks for consent at the one moment sunk cost makes refusing expensive.
agents · permissions · consent
- 22
Show the agent working
Visible reasoning is only worth its screen space if the user can act on what they see — a read-only stream of thought gives them the anxiety of watching without the power to intervene.
agents · transparency · control
Trust and uncertainty
Which claims the product vouches for, which it sources, and how a reader tells one from the other.
- 02
Mark what the product vouches for
One answer mixes quoted fact, fair summary and plausible invention — decide per claim whether the interface vouches for it, sources it, or declines to stand behind it.
trust · citations · uncertainty
- 13
Draw the certainty boundary
Record and prediction rendered in the same ink is the commonest way an interface overstates what it knows — reserve one visual property for epistemic status and draw the transition, not just the two regions.
forecasts · charts · uncertainty
- 14
Make the score answerable
A model-produced number nobody can interrogate is believed until the first visible miss and disbelieved permanently after it — answerability is what lets trust be repaired.
scores · explainability · trust
- 15
Keep the evidence on screen
A citation you have to click produces the appearance of verifiability rather than the fact of it — checking has to cost less than trusting, and a click already costs more.
citations · sources · verification
- 16
Record how it was made
A generated artifact outlives the conversation that produced it, so origin — model, inputs, and which parts a human changed — has to be a structured field travelling with the thing rather than lore in a chat log.
provenance · metadata · audit
Retrieval and discovery
Finding the right material, and why the machinery that makes retrieval work is a poor interface to it.
- 18
Model output as structure, not prose
Prose is terminal and structure is generative — the same model call spent on a facet applied across a corpus reshapes how everyone navigates it, where a paragraph helps one person once.
extraction · facets · navigation
- 19
The retrieval structure is not the interface
Graphs, embeddings, chunks and similarity scores are how retrieval works, not what anyone came for — shipping them as the interface hands the system's job to the user.
rag · search · restraint
- 23
The unit of work grows with the model
Products are shaped around what inference cost when they were designed, and that shape outlives the constraint — once reading everything is cheap, a per-item interface leaves the aggregation to the user.
scale · corpus · batch
Failure and recovery
What the interface does when the answer is wrong, absent, or half-delivered — and how someone gets back.
- 03
Design the failure state first
Draw the wrong-answer screen before the right-answer one — “the model failed” is five different situations that each need a different interface.
errors · empty states · trust
- 04
Undo over confirm
Apply the change immediately and hold the irreversible commit until the undo window closes — for an agent acting on someone's behalf, that staging point is the design.
agents · destructive · recovery
- 32
Don't animate a guess
Confident motion over state the system doesn't hold is a lie told at exactly the moment the user is deciding whether to trust it.
realtime · progress · honesty
- 33
Constrain the call, don't filter the output
Known failure modes belong in the request, where excluding them costs nothing — catching them afterwards means paying for the bad output and then explaining it.
prompting · guardrails · cost
Determinism and consistency
Holding something fixed across regenerations, and deciding what counts as asking the same thing twice.
- 34
Hold the invariant, vary the delta
A regeneration reads as the same thing changing only if something is deliberately held fixed — choosing what is invariant is a design decision, not a model setting.
consistency · identity · regeneration
- 35
Decide what counts as the same request
Whether this is the same ask as last time is the cache key, the cost model and the user's mental model all at once — let the three disagree and surprise bills and surprise outputs come from the same bug.
caching · cost · mental models
- 36
Smooth the gaps, don't invent the points
Rendering between values you hold is presentation; producing values you don't is fabrication — and a model makes the second as easy as the first, so the interface has to know which one it is doing.
interpolation · visualisation · honesty
Memory and context
What the product keeps between sessions, and how a history of attempts stays worth returning to.
- 24
Runs need a shelf
A reverse-chronological list answers what happened; the question people actually have is which of these is best, and that one needs them adjacent.
history · comparison · versions
- 25
Watch every stream at once
Supervision is noticing the one that went wrong, which needs peripheral vision across all of them — and tabs destroy peripheral vision by construction.
parallel · monitoring · agents
- 26
Generated things need generated names
Naming cost a proportionate amount of attention when making something was expensive; now creating takes a sentence and naming takes more thought than the creation did, so nothing gets named.
naming · history · findability
Data boundaries
Where content crosses out of someone's control, and what the interface owes them at that line.
- 05
Redaction moves to the export
Local inference doesn't delete the privacy boundary, it moves it — from the network call to the export, where content actually leaves the user's control.
privacy · on-device · enterprise
- 11
Answer within the boundary, and show its shape
A model with deliberately restricted context does not know what it is missing, so it answers fluently and incompletely — the interface has to render the gap rather than let the answer quietly degrade.
privacy · permissions · trust
Craft and production
How this work gets made and shipped — where generation belongs in a system, and what a demo has to contain.
- 31
Put the model where the work is
A capability delivered into the tool someone already has open beats a destination they have to remember to visit — the switching cost is paid on every single use.
embedding · integration · adoption
- 37
A cold product can't be judged
A data-shaped product with no data in it cannot be evaluated by anyone, including its own team — generation has made a plausible population cheap enough to be a design deliverable.
demo data · cold start · review
- 38
Generation touches tokens, never screens
Let a model move the system's variables and let deterministic composition build the screen — generation at the token layer is verifiable in one place, and at the screen layer it is verifiable nowhere.
design systems · tokens · consistency
Measurement
Telling whether a change helped, when the same input can produce a different answer tomorrow.
- 06
Evaluation loops
Keep twenty real cases fixed, run them after every change, and grade what the screen does — a single try tells you nothing when the output moves.
evals · measurement · process
- 39
Agree the measurement before the mock
Decide what would count as this working while it is still cheap to change the answer — instrumentation designed after the interface measures whatever happens to be easy.
experiments · metrics · instrumentation
- 40
Prototype the distribution, not the screen
A mock of one good output is a picture of the best case — when the output moves, the reviewable artifact is something running across many inputs.
prototyping · review · variance
Using these
Where a pattern has a longer argument behind it, the page links to it in the notes. If you are deciding one of these for a product right now, that is most of what a fractional engagement is: making the call and writing down why, so it settles an argument when nobody is in the room.