Key takeaways
- The AI sparkle promises instant magic but hides latency, uncertainty and error — that's design debt.
- Turn waiting into trust: narrate the model's steps, sources and reasoning instead of hiding a spinner.
- Honest cues restore what icons subtract: confidence levels, provenance, visible effort and reversibility.
- Design AI to invite collaboration, not to perform flawless authority it hasn't earned.
- Test every AI cue against three truths: effort, certainty, and human control.
Open almost any product shipped in the last two years and you'll find it: the little four-pointed sparkle. It has become the universal shorthand for "AI lives here." The problem is that the sparkle promises instant magic while the technology behind it does something far messier — it thinks, searches, hesitates, and sometimes gets things wrong. A growing collective of designers writing on UX Collective keeps circling the same uncomfortable question: are we decorating AI, or are we honestly explaining it? At Evocative, we think the sparkle is a design debt we're all quietly accumulating.
The gap between the icon and the work
When an answer takes time, the interface has a choice to make. Tools like Gemini, Perplexity, Copilot and Consensus have started treating that waiting moment as real UX territory rather than a loading spinner to hide. Deep AI research isn't a transaction; it's a process with steps — retrieving sources, comparing them, reasoning, drafting. The best interfaces narrate that process. They show the model reading, name the sources it consulted, and expose a chain of reasoning you can inspect. The sparkle says "trust me instantly." Honest AI cues say "here's what I'm doing, and here's why you can trust the result."
That distinction matters commercially. Users forgive a slow answer when they understand the effort behind it. They do not forgive a confident-looking answer that turns out to be invented. The latency you expose honestly becomes a credibility signal; the latency you hide becomes a frustration.
Tools are rulers — and rulers subtract
A ruler measures length by ignoring everything else about an object: its warmth, its weight, its history. Every tool we build does the same quiet subtraction, encoding a worldview while hiding what it leaves out. An AI cue is a tool in exactly this sense. A single sparkle flattens a vast, probabilistic, sometimes-wrong system into one tidy promise of correctness. It subtracts uncertainty from the picture — and uncertainty is precisely the thing users most need to see.
Designing honest cues means putting back what the sparkle removed:
- Confidence, visibly. Distinguish a well-sourced answer from a speculative one. Don't render both in the same authoritative tone.
- Provenance, by default. Show where a claim came from. Citations aren't clutter; they're the user's audit trail.
- Effort, as progress. Replace indeterminate spinners with meaningful steps: "searching 14 sources," "comparing results," "drafting."
- Reversibility. Make it obvious that the user can edit, reject or regenerate. AI output is a draft, not a verdict.
Go with the current, or change it?

There's an old image of two ways to shape a river: the pole, which goes with the current, and the stake, which stands against it to redirect it. Designers face this choice constantly with AI. The current right now is to sparkle everything, to anthropomorphise, to imply more intelligence than exists. Going with that current is easy and gets you shipped. Being a stake — insisting on honest, legible cues even when the trend rewards theatrical magic — is harder but it's where durable trust is built.
You don't always have to resist. Sometimes the current is fine. But you should know which you're doing and why, rather than defaulting to decoration because everyone else did.
Inviting, not pretending
Consider the little trash robot that doesn't pick up garbage but trundles over and asks you to hand it some. It's deliberately a bit helpless, a bit kawaii, and that mild awkwardness is the point: it invites participation instead of claiming competence. There's a lesson there for AI interfaces. A cue that admits "I might be wrong, help me get this right" invites collaboration. A cue that performs flawless authority invites blind trust it hasn't earned — and blame when it fails.
A practical standard for honest cues

Before you ship another sparkle, pressure-test it against three questions:
- Does it tell the truth about effort? If the model is working, show the work rather than a magic flourish.
- Does it tell the truth about certainty? Match the visual confidence of the output to its actual reliability.
- Does it keep the human in control? Every AI moment should leave an obvious exit, edit, or override.
Honesty isn't the enemy of delight here. Perplexity's visible source-gathering is genuinely satisfying to watch. The trash robot's awkwardness is charming. Honest cues can be beautiful — they just refuse to lie about what's happening underneath. That's the standard we hold ourselves to when we build AI features for clients: the interface should make the intelligence legible, not mythical.
Sources
- Beyond chatbots: UX for deep AI research — UX Collective
- Samia Halaby and the Amiga 1000 — UX Collective
- The pole and the stake — UX Collective
- What a ruler leaves out — UX Collective
- Schrödinger’s Huang: Nvidia could not be everything to everybody — UX Collective
- The trash robot that doesn’t pick up, but hands out — UX Collective