Traditional interfaces rest on a comforting assumption: the system is right. Click "calculate total" and the total is correct, every time. AI features break that assumption — the system is usually right — and most of the UX work is designing for the gap between usually and always. The uncertainty doesn't go away when you add a friendly chat bubble; it just becomes the user's problem unless you design for it. (METR even found users can't reliably sense AI's impact on their own output, which means the interface has to surface what the user can't feel.)
What changes
- Outputs are suggestions, not facts. Signal confidence, invite correction, and never present a guess as gospel. Phrasing and visual weight matter: a tentative answer dressed up as a definitive one is a trust trap.
- Latency is variable. A model might respond in 300ms or 30 seconds. Streaming and graceful waiting become core mechanics, not polish you add at the end.
- Errors are different. The model doesn't crash with a stack trace — it's confidently, fluently wrong. The dangerous failure is the plausible one. Make noticing and undoing effortless.
Why this matters
Trust is the whole game. Users abandon AI features not because the model is occasionally wrong — they expect that — but because the interface gave them no way to tell when it was wrong, or no easy way to recover. A feature that's right 95% of the time but hides the 5% will feel less trustworthy than one that's right 85% of the time but is honest and easy to correct. Perceived reliability comes from the design as much as the model.
Patterns that work
- 1.Human in the loop by default — draft, don't send; suggest, don't decide. Put the user in control of the consequential action.
- 2.One-click correction — editing, regenerating, rejecting. Friction here kills trust faster than the occasional bad answer.
- 3.Show your work — citations, sources and the reasoning behind an answer build the trust probabilistic systems otherwise lack.
- 4.Design the empty and wrong states first — they're most of the experience, and they're where naive AI products fall apart.
Good AI UX doesn't hide that the system is uncertain. It makes that uncertainty safe, visible and easy to work with.
What this means for your team
Treat the wrong answer as a first-class design state, not an edge case. Before you polish the happy path, prototype what happens when the model returns something off, slow, or empty — because for AI features that's not the exception, it's a routine occurrence. Give users a fast undo, a visible "this is a draft," and a clear path to override. This is the same instinct behind the broader human-in-the-loop pattern: the human stays in control where the stakes are real. For a deeper look at building interfaces people trust, see designing trustworthy AI interfaces, or talk to us about your own product.
Sources
- METR — Developer productivity RCT