AI UX Design: Patterns, Latency and Fallback States
How to add AI features without hurting UX: choosing interaction patterns, disclosure, fallback states and latency handling so the feature feels useful, not like a gimmick.
Most AI features do not fail because the model is bad. They fail in the seconds after the user clicks: an unclear spinner, a confident wrong answer, or no route forward when the service times out. Good AI UX design treats those moments as part of the product. Too often they get treated as edge cases.
This guide covers the four things that decide whether AI-assisted features feel useful or feel bolted on: the interaction pattern, the disclosure convention, the fallback state and how latency is handled. It is written for the person who has to sign off the build and defend it afterwards.
Get an AI feature that survives real users, slow responses and wrong answers, designed and engineered end to end.
Is this a feature or a demo?
The first decision is not which model to use. It is how the user invokes the AI, and what happens to their work when it acts. There are three broad patterns, and each one carries a different cost when the output is wrong.
- Ambient: the system suggests without being asked. Think ghost text in GitHub Copilot or Gmail’s Smart Compose. Ignoring a suggestion has to cost nothing, so it only works for high-frequency, low-stakes tasks where a single keystroke accepts or dismisses it.
- Invoked: the user asks explicitly through a button, a command palette or a prompt field. Because the user chose to wait, the feature can afford a few seconds of latency. It still has to show its work.
- Delegated: the user hands over a multi-step task, such as reconciling invoices or drafting a campaign brief from a CRM record. This is where agent-style products sit, and it needs review checkpoints, a visible plan and a way to reverse every action.
The gimmick usually comes from a mismatch. Put a chat box where an inline suggestion belonged and you add steps. Hand a delegated agent a task where a wrong action is expensive and give it no review step, and you add risk. Before anyone opens Figma, write down how often the task happens, how bad a wrong output is, and how easily the user can spot a wrong output. That combination picks the pattern for you.
If you cannot answer those questions with evidence, a short UX research sprint will get you that evidence for far less than the cost of shipping the wrong pattern.
Latency is a design material
Large language models are slow compared with everything else in your interface. A database query comes back in milliseconds. A generated paragraph can take several seconds, and the time varies with prompt length, output length and how loaded the provider is.
The human side of this has been stable for decades. Nielsen Norman Group’s guidance holds that 0.1 second is about the limit for a system to feel instantaneous, 1.0 second is about the limit for the user’s flow of thought to stay uninterrupted, and 10 seconds is about the limit for keeping their attention. The same article says that feedback during a delay matters most when response time is highly variable. That describes generative AI exactly.
So you design for each band separately:
- Under 1 second: classification, autocomplete, smart defaults. Use small, fast models or precomputed results. No loading treatment is needed. If you cannot reliably hit this band, you probably should not be using the ambient pattern.
- 1 to 10 seconds: most invoked generation. Stream the output token by token over server-sent events, so time to first token becomes the number users actually feel. Before the first token arrives, show what is happening (“Reading 14 support tickets”) rather than a generic spinner.
- Over 10 seconds: document analysis, multi-step agents, image generation. Move the work to the background, let the user keep working, and notify them when it is done. A progress state that names each step does more than a fake percentage bar.
Measure time to first token and p95 completion time, not average response time. Averages hide the slow tail, and the slow tail is where users decide the feature is broken.
There are engineering details a capable supplier will raise without being asked. Every request needs a Stop control that actually cancels the upstream call, so you are not paying for tokens nobody will read. Set hard timeouts for each feature. Cache deterministic results. And reserve layout space for streamed content, because text that pushes the page around as it arrives produces layout shift and makes the interface feel unstable.
Disclosure that earns trust
The sparkle icon has become the industry’s shorthand for “AI did this”. It is fine as a wayfinding cue. It does nothing for trust, because it tells the user what produced the content and nothing about how far to rely on it.
Useful disclosure works at three levels:
Avoid showing raw confidence scores. A percentage label next to generated text suggests a precision the model does not have, and most users cannot act on it. Translate uncertainty into behaviour instead: show several options when the model is unsure, ask a clarifying question, or decline and route the user to the manual path.
There is also a regulatory reason to get this right. Article 50 of the EU AI Act sets transparency obligations: people must be told when they are interacting with an AI system unless it is obvious from context, and certain synthetic content must be marked as such. If you serve EU users, put disclosure in the design system as a component with its own rules. Do not leave it as a copy decision made screen by screen.
Origin:
Label generated content at the point where it appears, not in a terms page. Keep the label visible after the user edits the content, until they have accepted it as their own.
Grounding:
Show what the output is based on. Link a summary back to its source records, and anchor an answer to the passages it came from. Users verify grounded claims in seconds. Ungrounded claims they either trust blindly or ignore completely.
Limits:
Say plainly what the feature cannot do, close to where the user starts the task. One sentence such as "Drafts are based on the last 90 days of account activity" will stop more misuse than any disclaimer.
Fallback states: when the model is wrong, slow or down
A traditional feature has a small set of failure states. An AI feature has more, and they look different to the user. The model can time out. The provider can have an outage or hit you with rate limits. A safety filter can refuse the request. Retrieval can return nothing relevant. Worst of all, the model can return something fluent and wrong.
Each of these needs its own designed state. “Something went wrong” is not one of them. Here is the sequence we would expect a delivery team to work through:
Google’s People + AI Guidebook and Microsoft’s Guidelines for Human-AI Interaction both make the same point. Efficient correction and clear error handling are part of the core interaction, not a polish pass. In practice, the plausible-but-wrong case is handled by grounding (see above) and by keeping the user in the approval seat for anything that writes, sends or deletes.
List the failure modes:
For each AI feature, write down every way it can fail, including the plausible-but-wrong output. Rank them by how often they will happen and how much damage they do.
Keep a manual path:
Every AI-assisted task must still be possible without the AI. If generating the summary fails, the user still gets the raw records. If smart search fails, keyword search still runs.
Preserve user input:
When a request fails, keep the prompt, the selections and any partial output. Making someone retype a long instruction is the fastest way to teach them never to use the feature again.
Write state-specific copy:
Tell the user what happened and what they can do next. "This document is too long to summarise in one pass. Summarise by section instead?" is a fallback. "Error 429" is not.
Degrade gracefully at the system level:
Route to a secondary model or provider when the primary one fails. Use circuit breakers so an outage switches off the AI entry points cleanly instead of leaving dead buttons.
Close the correction loop:
Make editing, regenerating and undoing a single action each. Log what users correct, because those corrections are your best evaluation data.
Control, correction and accessibility
Users forgive an AI feature that is sometimes wrong if fixing it is cheap. They do not forgive one that acts on their data without asking.
A few conventions make the difference. Write generated changes as proposals: a diff the user can accept, edit or reject, not an overwrite. Make thumbs-up and thumbs-down feedback do something visible, even if that is only “We will use this to improve suggestions for your team.” And remember dismissals: a suggestion the user rejected three times should stop appearing.
Streaming output creates accessibility problems that design reviews often miss. A screen reader announcing every token as it arrives is unusable. The usual approach is to mark the response region as a polite live region, announce once when generation starts and once when it finishes, and make the full response available for reading in one piece. Focus management after the response arrives, and keyboard access to Stop and Regenerate, belong in your WCAG conformance checks like any other component.
How do you know it is working?
Do not judge an AI feature by whether people use it. Novelty drives clicks in the first weeks. What you want to know is whether the output was worth keeping.
- Acceptance rate: the share of suggestions accepted without edits, accepted with edits, and discarded.
- Edit distance: how much users change accepted output. Heavy edits mean the feature is producing drafts, not answers, and the design should say so.
- Abandonment during wait: sessions where the user navigates away or presses Stop before completion. This is your latency metric expressed in behaviour.
- Fallback rate: how often each failure state is triggered, by type.
Before launch, build an evaluation set of real inputs, including messy and adversarial ones, and rerun it every time a prompt or model changes. Then watch real people use it. A moderated usability test where you deliberately trigger a timeout and a wrong answer will tell you more about the feature than a week of demos. If the AI feature sits inside an existing product, include it in the scope of any UX audit so it is judged against the journeys around it, not on its own.
The quickest test for a supplier is simple. Ask them to show you the timeout state, the refusal state and the wrong-answer recovery for the feature they are proposing. If they only have the happy path in the prototype, you are buying a demo.
FAQs
What makes an AI feature feel like a gimmick?
Usually a mismatch between the interaction pattern and the task. Examples include a chat interface where an inline suggestion would be faster, slow responses with no feedback, output that cannot be checked against a source, or no manual route when the AI fails. Users drop features that add steps or risk without saving effort.
How fast does an AI feature need to respond?
It depends on the pattern. Ambient suggestions need to feel instantaneous, which Nielsen Norman Group puts at around 0.1 second. Invoked generation should start streaming within about a second to protect the user’s flow. Anything likely to take more than about 10 seconds should run in the background with progress and a notification.
Do we have to label AI-generated content?
For users in the EU, Article 50 of the EU AI Act sets transparency obligations for AI systems that interact with people and for certain synthetic content. Even where it is not legally required, labelling content at the point where it appears, and showing what it is based on, builds trust and reduces misuse.
Should we show users a confidence score?
Rarely. Raw percentages suggest false precision, and most users cannot act on them. It is better to turn uncertainty into behaviour: offer several options, ask a clarifying question, or decline and route the user to the manual path.
What should happen when the AI provider goes down?
The task should still be possible without the AI. Keep the user’s input, show a clear state-specific message, fail over to a secondary model where possible, and use circuit breakers so the AI entry points switch off cleanly instead of failing one request at a time.
Which metrics show whether an AI feature is working?
Acceptance rate, how heavily users edit accepted output, abandonment during the wait, and how often each fallback is triggered. Raw usage numbers are misleading in the first weeks because novelty inflates them.
Design AI features users keep using
You have seen how interaction patterns, disclosure, fallback states and latency handling decide whether an AI feature earns its place. Moburst Digital Experience can design and build each of those states, from streaming responses to graceful degradation, so the feature works when the model does not.