Builder's Brain
Builder's Brain · the neuroscience of building · ◉ Evergreen

Why showing the work beats the instant answer

by Shreyansh Ojha·6 min·Working Theory

I’ve argued on this site that latency is an emotion — that a slow product doesn’t just cost seconds, it costs trust and calm, and that shaving delay is one of the highest-leverage things you can do. I still believe that. So it’s worth being honest when the research turns up a genuine exception, because this one is sharp and it looks, at first, like a direct contradiction.

Buell and Norton ran a study with a travel-search site. One version returned flight results instantly. Another inserted a short wait with a running commentary — now searching United… now searching Delta… now checking American — so you watched it work before it showed you anything. The second version made people wait longer, and they liked it more. Higher satisfaction, more trust in the results, a stronger sense that the site had done a thorough job. The delay, spent visibly working, didn’t read as slowness. It read as effort, and effort read as value.

They called it the labor illusion, and the mechanism is a shortcut we all run without noticing. You usually can’t judge the quality of a result directly — you have no way to know whether the site really checked every airline, whether the model actually read the whole document. So you substitute a cue you can see: did it look like it worked? In the physical world, effort and worth genuinely tended to correlate — the meal that took an hour, the report that took a week — so the brain learned to treat visible labor as a proxy for value. Show the labor and the proxy fires. Hide it, hand over an instant answer from a black box, and there’s nothing for trust to grab onto.

instant ✦ done "…did it really check?" trust: low shows the work searching 40 sources… ✓ scanned pricing ✓ checked 3 airlines ✓ compared dates …assembling result trust: high
Same result, same underlying work. The one that lets you watch it happen is believed — and valued — more. Original diagram · Working Theory

Here’s how this reconciles with the latency essay rather than blowing it up, because the resolution is the whole point. There are two kinds of waiting, and they are not the same thing. Dead waiting — a meaningless spinner, a page that’s just slow, time you can’t account for — is pure cost, and everything I said about killing latency applies at full force. Working waiting — a brief, honest, legible display of relevant effort — can be an asset, because it isn’t empty time, it’s evidence. The rule “unexplained delay is an emotional tax” still holds exactly. This just adds a corollary: if you have real work the user can’t see, making it visible can convert the wait from a tax into a reason to trust you.

Which tells you precisely when to reach for it and when not to. Show the work when the value is genuinely uncertain and the process is genuinely substantial — an AI that really did read forty documents, a search that really did check a hundred sources, an analysis doing something the user couldn’t do themselves. Let them watch. But don’t dress up the waits where the user just wants the thing done and knows exactly what they asked for — logging in, loading their inbox, completing a checkout. There, every millisecond is pure cost and a “processing…” theater is insulting. And the hard line: the labor you show has to be real. A progress bar narrating work that isn’t happening — “analyzing your profile…” while it sleeps for a beat — is a dark pattern, and the trust it builds detonates the instant someone realizes it was staged.

That’s the obvious objection, and it deserves a straight answer: isn’t this just manipulation, adding artificial slowness to seem impressive? It’s manipulation if the work is fake. It’s communication if the work is real. Telling a user that your model actually consulted forty sources isn’t a trick — it’s surfacing something true they’d otherwise never know, and the fact that the truth also makes them value the result more is not a reason to hide it. Refuse the fake version. Embrace the honest one. They only look alike from the outside.

I’ll flag the science’s edges too, because this effect is real but not a law. Push it too far and visible effort stops reading as diligence and starts reading as inefficiency — why is this taking so long? — and for expert users doing the same task for the hundredth time, the novelty is gone and raw speed wins again. So it’s a tool, not a default. The question it leaves you with isn’t “how do I make this faster,” and it certainly isn’t “how do I make this feel like more work.” It’s this: does my product do something real the user can’t see — and would they trust it more if, for just a moment, they could? If so, don’t hide the work. Show it, briefly and honestly, and let them watch it happen.

The science, to look up: the labor illusion (Ryan Buell & Michael Norton, 2011); operational transparency (Buell); the effort heuristic (we infer quality from perceived effort). Real and replicated, but context-bound — it flips when the shown effort reads as inefficiency, and for expert or repeat users speed wins again.

Liked this? Get the next one in Working Theory.

Going weekly in August (it's in beta now). One genuinely interesting read on building, the brain, and the science most people missed.

Got a reaction, a counter-example, or something I missed? Reply by email — I read everything.
◉ join in

Where have you hit this — in a product you use, or one you're building?

Threads open here soon. For now, the conversation lives two clicks away — discuss on GitHub, or just reply by email. I read and answer everything.