Module 08 — AI UX Design

Goal of this module: Learn to design user experiences for AI — software that is uncertain, sometimes wrong, sometimes slow, and probabilistic. Traditional UX assumes the software is reliable and deterministic; AI breaks that assumption, so AI UX needs new patterns. You’ll learn how to set expectations, build appropriate trust, handle latency, design for errors, and keep users in control. Good AI UX is often the difference between a feature people love and one they abandon.

8.1 Why AI needs its own UX discipline

Traditional UX is built on a promise: the software does what it says, the same way every time. A button always does the same thing. AI breaks that promise — it’s probabilistic (Module 00), it can be confidently wrong (hallucinations), it can be slow and variable, and its capabilities are fuzzy (users can’t tell what it can and can’t do).

AI UX is the practice of designing experiences that help people use an uncertain, fallible tool effectively — getting value from it while being protected from its mistakes. The central challenge: design so the user gets the benefit of the AI without being misled by its failures.

Crucially, UX is a safety mechanism, not just decoration. A well-designed interface prevents the “overreliance / misinformation” risk from Module 06 (users trusting hallucinations as fact). It’s the last line of defense between a wrong AI output and a bad real-world decision by the user. Designers and engineers share responsibility for this.

8.2 The core tension: trust calibration

The single most important concept in AI UX is calibrated trust: helping users trust the AI exactly as much as it deserves — no more, no less.

Over-trust is dangerous: users accept wrong answers, act on hallucinations, stop checking. (A user who copies a hallucinated legal clause into a contract.)
Under-trust wastes the AI: users ignore good suggestions, double-check everything, get no benefit. (A user who never uses the helpful draft because they don’t believe it.)

Good AI UX constantly signals how much to trust this particular output. It celebrates the AI’s strengths while being honest about its limits. Every pattern below serves trust calibration in some way. Hold this as your north star: you are designing the user’s trust, not just the interface.

8.3 Setting expectations (before and during use)

Users bring expectations from sci-fi and marketing hype. Reset them to reality.

Be honest about what it is and isn’t. Tell users it’s an AI, what it’s good at, and that it can make mistakes. A simple, visible “AI can make mistakes — verify important information” is doing real safety work (and is increasingly expected or required).
Communicate capabilities and boundaries. Show examples of what to ask. Nothing frustrates users like guessing what an AI can do and repeatedly hitting walls. Suggested prompts, example queries, and onboarding all help users find the “happy path.”
Set latency expectations. If something takes 20 seconds (a complex agent task), say so up front, rather than leaving the user staring at a frozen screen wondering if it broke.

8.4 Designing for latency (AI is slow, and variable)

Models are slow compared to normal software — seconds, not milliseconds — and the time varies a lot (Module 09’s tail latency). UX must make waiting bearable and informative.

Streaming. Show the answer as it’s generated, word by word, instead of making the user wait for the whole thing. This is the signature AI UX pattern. It dramatically improves perceived speed (the user sees progress immediately) even if total time is unchanged. The key metric is time to first token — how long until something appears (Module 03). Optimize that, and the wait feels short.
Show progress for multi-step work. For agents that take many steps (Module 01), show what’s happening: “Searching your documents… Reading 3 sources… Drafting an answer…” This turns dead waiting time into a sense of progress and competence, and builds trust by revealing the work.
Skeletons and typing indicators for shorter waits, so the interface never looks frozen.
Let users do something else. For long tasks, let them queue it and get notified, rather than blocking the whole UI.

Perceived performance often matters more than actual performance. Streaming and progress indicators can make a 10-second response feel faster than a silent 4-second one.

8.5 Communicating uncertainty and enabling verification

This is where AI UX does its most important safety work — directly countering hallucinations and overreliance (Module 06).

Show sources / citations. When the answer is based on retrieved documents (RAG, Module 01), link to them. This lets users verify, builds appropriate trust, and turns “trust me” into “here’s why.” Citations are one of the highest-value AI UX patterns — they convert an unverifiable claim into a checkable one.
Signal confidence honestly where you can. Distinguish “here’s a direct quote from your document” (high confidence) from “here’s my best guess” (low confidence). Avoid fake precision, but don’t present everything with uniform false confidence.
Make verification easy, especially for high-stakes output. If a user is about to act on AI output (sign a contract, send an email, run code), make it natural to review and edit first. Friction in the right place (before an irreversible action) is good design — it connects to the human-in-the-loop gates of Module 07.
Don’t disguise AI guesses as established facts. Phrasing, formatting, and tone should match the actual reliability of the content.

8.6 Designing for errors and being wrong

The AI will be wrong sometimes. Design assuming it. The quality of an AI product is often defined by how gracefully it handles its own mistakes.

Make correction easy. Let users edit AI output, regenerate, give more guidance, or undo. The AI’s answer should be a starting point the user can shape, not a final verdict they must accept or reject wholesale.
Always provide an escape hatch. A clear way to reach a human, get help, or bypass the AI when it’s not working. Never trap a user in a loop with an AI that can’t help them — that’s where AI products earn their worst reputations. (The escape hatch is also the reliability fallback of Module 09 and the escalation path of Module 07.)
Fail gracefully and honestly. When the AI can’t answer or something breaks, say so clearly and offer a next step. Don’t fabricate an answer to avoid admitting “I don’t know” — a confident wrong answer is far worse than an honest “I’m not sure, here’s how to get help.”
Make AI actions reversible where possible. Undo, drafts before sending, confirmations before irreversible steps. Reversibility lets users trust the AI enough to use it, knowing mistakes are recoverable.

8.7 Feedback and control

Easy feedback (thumbs up/down, report). This serves double duty: it gives users a sense of control and it’s a primary signal for observability and evaluation (Modules 02–04). Every feedback widget is both a UX feature and a data pipeline. Make it low-friction or people won’t use it.
Keep the user in control. The user, not the AI, should be the one making consequential decisions. The AI suggests, drafts, accelerates; the human decides and directs. This “AI as copilot, human as pilot” framing reassures users and aligns with the human-in-the-loop philosophy (Module 07).
Respect user agency and effort. Don’t auto-apply big changes without consent. Don’t bury the user in AI suggestions they didn’t ask for. The AI should feel like a helpful collaborator, not a pushy or intrusive one.

8.8 Conversational vs. embedded AI UX

Not all AI UX is a chatbot. Two broad styles, each with different design needs:

Conversational (chat) UX: open-ended, flexible, but puts the burden on the user to know what to ask (the “blank box problem”). Help with suggested prompts, examples, and good onboarding. Powerful for exploration; can be intimidating or aimless without guidance.
Embedded / inline AI: the AI is woven into an existing workflow — autocomplete, a “summarize” button, smart suggestions, inline edits. Often a better experience because it’s contextual, constrained, and the user doesn’t face a blank box. The AI augments what the user is already doing. Much production AI is shifting toward embedded patterns precisely because they’re easier to make reliable and to use.

Design insight: A narrower, more constrained AI feature is usually easier to make good (for the user) and reliable (for you) than an open-ended “ask me anything” box. Constraints help both sides. When you can, embed the AI in a specific task rather than offering an open chat.

8.9 Accessibility, inclusivity, and tone

Accessibility: streaming text, screen-reader compatibility, keyboard navigation, and not relying on color alone to signal confidence. AI features must meet the same accessibility bar as the rest of your product.
Inclusive and unbiased outputs: UX choices (default prompts, examples, tone) can amplify or reduce bias. Test with diverse users and inputs. Biased or culturally tone-deaf output is both a UX failure and a safety/ethics issue (Module 06).
Consistent, appropriate persona. The AI’s tone should match your brand and the context — and stay consistent. A wildly varying or inappropriately casual persona erodes trust.

8.10 Common AI UX mistakes

Pretending the AI is perfect — no uncertainty signals, no “can make mistakes” note, hallucinations dressed as facts. Breeds dangerous over-trust.
No sources/citations when answers come from documents, leaving users unable to verify.
Silent, frozen waits instead of streaming and progress — users assume it’s broken and leave.
No escape hatch to a human, trapping frustrated users with an AI that can’t help.
Making AI output hard to edit or undo, forcing accept-or-reject on an imperfect draft.
Blank-box overwhelm — an open chat with no guidance on what to ask.
Burying or omitting feedback controls, losing both user trust and your best quality signal.
Auto-acting without consent on consequential changes, removing user control.

8.11 Try this

Trust-calibrate a screen. For your support assistant’s answer screen, list every element that signals how much to trust this answer (citations, confidence wording, “verify important info,” etc.). Is there enough? Too much?
Design the wait. Your assistant sometimes takes 15 seconds (it searches docs, then drafts). Design exactly what the user sees during those 15 seconds, second by second. What’s your time-to-first-token target?
Design the failure. Write what the user sees when the assistant genuinely can’t answer their question. Include the honest message and the escape hatch. Compare it to the (bad) alternative of fabricating an answer.

8.12 Self-check

What assumption of traditional UX does AI break, and why does that demand new patterns?
Explain calibrated trust and the dangers of over- and under-trust.
Why is streaming so effective, and what metric does it optimize?
Name three UX patterns that counter hallucination and overreliance.
Why is an “escape hatch to a human” essential, and how does it connect to Modules 07 and 09?
Contrast conversational and embedded AI UX, and explain why constraints help.

Next: Module 09 — Reliability & Performance. We’ve made the experience good; now we make sure it stays up and fast under real load.