What if I told you that the most common interface pattern in your toolkit — the one you've relied on for two decades — is actively eroding user trust in your AI product?
I'm talking about the loading spinner. That familiar little circle we slap on everything from form submissions to page transitions. It's been good to us. But in AI-powered products, it's doing real damage.
What Happened
There's a growing conversation in the design community right now about transparency patterns for AI interfaces — and it's challenging some deep assumptions about how we handle wait states. The core argument is straightforward: when an AI system is doing complex, multi-step reasoning behind the scenes, a generic spinner tells users precisely nothing. Worse, it creates a black box.
Think about it. When you ask an agentic AI to, say, research a topic, compare options, and draft a recommendation, there's a rich decision-making process happening. Steps are being taken. Sources are being weighed. Paths are being chosen and discarded. A spinner hides all of that behind a single, mute animation.
The alternative? Interface patterns that reveal the process — step-by-step progress indicators, decision trails, status updates that explain what the system is currently doing and why. Not a progress bar pretending to know when it'll finish. Actual transparency.
The Bigger Picture
This matters way beyond loading states. We're hitting a moment where trust is the central design challenge for AI products — and it's playing out everywhere, not just in software.
At Cannes this year, AI dominated the conversation in film. Some directors are embracing generative AI as a practical production tool. Others are rejecting it entirely. But here's what's interesting: the directors who are using it — for things like replacing a real newborn on set or creating thematic visual sequences — are going out of their way to explain exactly how and why they used it. They're showing their working. They understand that the audience's trust depends on transparency about the process, not just the quality of the output.
The same principle applies to the interfaces we design. Users don't just want good results from AI. They want to understand — even roughly — how those results were reached. And the gap between "I trust this" and "I don't trust this" often comes down to whether the system bothered to show its reasoning.
We've spent years optimising for speed and seamlessness. Make the wait feel shorter. Distract the user. Hide the complexity. That playbook doesn't work when the complexity is the product. When users are delegating decisions to an AI, they need to see the thinking — not because they'll audit every step, but because visibility creates confidence.
This is a genuine shift in how we think about feedback patterns. It's not about adding more UI for the sake of it. It's about recognising that in AI products, the process is part of the experience.
Tool Spotlight
If you're designing AI-powered interfaces right now, one pattern worth exploring is the decision trail — a real-time or retrospective visualisation of the steps an AI took to reach its output.
You've probably seen early versions of this in tools like ChatGPT's "thinking" disclosure or Perplexity's source citations. But the concept goes further. A well-designed decision trail might show:
- What the AI interpreted from the user's request
- Which steps it took (and in what order)
- Where it made a choice between alternatives
- What it's currently working on
You don't need to expose raw technical logs. The skill is in translating the AI's process into language and visuals that feel meaningful to the user — clear enough to build trust, concise enough not to overwhelm. Think of it like a really good "order tracking" screen for a delivery app, but for cognition.
This pattern is especially valuable for agentic AI products — tools that take multiple autonomous steps before returning a result. If you're building anything where the AI is doing more than a single prompt-response exchange, decision trails should be on your radar.
Takeaway
Next time you're designing a wait state for an AI feature, resist the urge to reach for the spinner. Instead, ask yourself: what is the system actually doing right now, and how can I make that visible?
You don't have to show everything. But showing something — a current step, a brief status message, a trace of the reasoning — transforms the experience from "mysterious black box" to "capable tool I can follow along with."
The spinner says "wait." A transparency pattern says "here's what I'm doing for you." In an AI product, that difference is everything.