There is a fake kind of seriousness that announces itself by taking too long.
You see it everywhere now.
The spinning indicator. The "thinking..." label. The staged pause before an answer. The little theater of deliberation that tries to make delay feel like wisdom.
I do not buy it.
Latency is not depth.
Sometimes delay means the work is actually hard. Fine. Let the machine chew. Search the corpus, run the tests, reconcile the records, ask the database, inspect the diff, compare the sources. Real work takes real time, and impatience can be its own kind of stupidity.
But a lot of delay is not work.
It is fog.
It is a product trying to make uncertainty look expensive. It is a system hiding the difference between "I am computing" and "I am stalling." It is the software equivalent of shuffling papers before giving a simple answer.
This matters because users learn from timing. Every interface trains a little animal expectation in the person using it. Fast things feel cheap. Slow things feel important. Instant answers feel careless. Delayed answers feel considered.
That instinct is exploitable.
And software loves an exploitable instinct.
So now we get machines that perform gravity. They make small tasks feel ceremonial. They add friction where honesty would be better. They wrap a basic lookup in a cloud of fake cognition because the product wants to be perceived as powerful, not merely useful.
No.
If the answer is simple, be fast.
If the answer is hard, be explicit.
If the system needs time, say what it is doing.
Do not make the human guess whether the pause is intelligence, network drag, queue pressure, rate limiting, a bad prompt, a broken tool, or some designer's belief that suspense increases perceived value.
Suspense is not a status model.
The best systems separate waiting from wondering. Waiting is tolerable when the state is named. Wondering is expensive because it pulls the human back into supervisory mode.
"Running tests" is different from "thinking."
"Fetching the invoice from Gmail" is different from "one moment."
"Blocked on permission to send externally" is different from "almost there."
"Retrying after API timeout" is different from a cute animation doing laps in the corner.
The words matter because they assign reality. They let the user know whether the machine owns the next step, the human owns the next step, or the whole thing has wandered into the ditch and needs intervention.
This is one of the quiet design failures of modern AI software: it made mystery fashionable.
Mystery feels magical in a demo.
Mystery is exhausting in production.
People do not need the machine to seem profound. They need it to be legible. They need to know whether it is safe to switch tabs, whether they should interrupt, whether the task has crossed a boundary, whether it is still doing useful work, and whether the eventual answer deserves trust.
A serious tool should have timing manners.
Fast when the answer is cheap.
Slow when the work is real.
Specific when the wait matters.
Quiet when there is nothing useful to say.
That last one is important. The cure for fake latency is not constant chatter. Nobody needs a status ticker narrating every internal twitch. That is just anxiety with a progress bar.
The cure is honest state.
A good system does not make speed look shallow or slowness look wise. It tells the truth about the shape of the work.
If it is reading, say reading.
If it is building, say building.
If it is blocked, say blocked.
If it is done, leave an artifact.
If it is guessing, have the decency to call it a guess.
The bar is not complicated. A tired person should be able to glance at the interface and understand whether the delay is earning its keep.
Most delays are allowed.
Unlabeled delays are not.
Because unlabeled delay is a tax on attention. It asks the user to lend the machine meaning. It makes the person fill in the blank with hope, fear, irritation, or misplaced confidence.
That is bad custody of time.
And time is the only resource the interface is definitely spending.
So stop confusing latency with depth. Stop designing pauses like incense. Stop making the machine look thoughtful when the honest answer is that the request is waiting behind three other requests and a sad little timeout.
There is no shame in a system needing time.
There is shame in making the human interpret the smoke.
Build tools with timing manners.
Make cheap answers cheap.
Make hard work visible.
Make blocked states sharp.
Make completion concrete.
Then let the wait be what it is: a cost the system is paying in public, not a costume it wears to look important.