You press "Summarise" on a long report. A grey spinner appears in the middle of the page and stays there. After fifteen seconds you click the button again, because you honestly cannot tell whether anything is happening. Now it is writing two summaries.
That small moment is the whole problem with AI features. A language model takes real time to think and write, often several seconds and sometimes much longer. You cannot always make it faster. You can decide what the person sees while it works, and that decision changes whether the wait feels like progress or like a broken button.
Why AI waits feel worse than normal waits
Most of the web trained us to expect answers in under a second. A search result, a page, a "liked" heart: all close to instant. AI breaks that habit in two ways.
First, the wait is longer. Writing a paragraph, reading a file or generating an image can take anywhere from a couple of seconds to a minute.
Second, the wait is unpredictable. The same button can take three seconds on one request and thirty on the next, depending on how much the model has to read and write. People handle a long wait they can predict much better than a short wait they cannot.
So the job is to answer the question every waiting person is silently asking: "Is it working, and how long will this take?"
The three time limits that still hold
The most useful rule here is more than thirty years old. In his 1993 book Usability Engineering, Jakob Nielsen set out three response-time limits, building on earlier work by Miller (1968) and Card and colleagues (1991). Nielsen Norman Group still publishes them as the three important limits:
| Time | What the person feels | What to show |
|---|---|---|
| About 0.1 second | The system reacted instantly | Just the result |
| About 1 second | They notice the delay, but their train of thought stays intact | A small sign that the click registered |
| About 10 seconds | The limit for keeping attention on the task | Clear feedback on progress and when it will finish |
Almost every AI feature lives past the 1-second line, and many go past 10. That tells you the design work is unavoidable. It is also the first of Nielsen's ten usability heuristics, "visibility of system status": the design should always keep people informed about what is going on, through feedback within a reasonable amount of time.
Pick the indicator by the length of the wait
Nielsen Norman Group's guidance on progress indicators (Katie Sherwin, 2014) gives a simple ladder:
- Under 1 second: show nothing extra. A spinner that flashes for a quarter of a second is more distracting than helpful.
- About 2 to 10 seconds: a looping indicator, such as a spinner, is fine, ideally with a few words that say what is happening ("Reading your document…").
- 10 seconds or more: use a percent-done indicator or another sign of real progress, and give people a way to stop.
The same article describes a University of Nebraska-Lincoln study where people who saw a moving progress bar were willing to wait, on average, three times longer than people who saw nothing. The wait was the same length. Only what they could see had changed.
Two things the article says to avoid are worth repeating, because AI products still do both: a static "Loading…" label that never changes (people cannot tell if it has frozen), and a "Please don't click again" warning. Show that the first click was accepted instead. That alone would prevent the double summary from the opening.
For a whole page that is still assembling, a skeleton screen helps. A skeleton is a grey outline of the layout that fills in as content arrives. Nielsen Norman Group's Skeleton Screens 101 (2023) recommends them for full-page loads of up to about 10 seconds, spinners for a single card or module, and a progress bar with a time estimate for anything longer.
Five patterns made for AI features
The ladder above was written for ordinary software. AI adds a few patterns of its own.
1. Stream the answer as it is written
Most large language model APIs can send the response piece by piece instead of all at once. Anthropic's documentation, for example, describes how you can stream a response incrementally using server-sent events, a standard way for a server to keep sending updates to the browser. In plain terms: the first words can appear on screen while the rest is still being written.
Streaming turns a long blank wait into reading time. The person starts taking in the answer instead of staring at a spinner. If your feature produces text, this is usually the single biggest improvement you can make.
2. Name the steps, not just the spinner
When the AI does several things in a row (searching, reading, drafting, checking), say which one it is on. A short line that changes, like "Searching 3 sources" then "Reading the contract" then "Writing the summary", tells people that time is being spent on their task. It also gives them a rough sense of how far along it is, even without a percentage.
Keep these lines honest. Only show a step the system is actually doing. Invented "thinking" messages that cycle on a timer are a small lie, and people notice when the same three phrases repeat.
3. Set expectations before the click
If a task usually takes a while, say so on or near the button: "Takes about a minute." Google's People + AI Guidebook advises teams to communicate what the product can and cannot do, clearly and early. Time is part of that. A person who knows a report takes a minute will go and make tea. A person who expected two seconds will start clicking things.
4. Let people keep working, and let them stop
For long jobs, do not lock the whole screen. Run the job in the background, show its status in one place, and let people carry on with something else. Always offer a clear Stop or Cancel. Sherwin's article recommends a way to stop for long processes, and for AI it matters even more: often someone realises halfway through that they asked the wrong question.
5. Show the partial result, then the final one
When you can, show something useful early: a first draft, the first image, the list of sources found. Then refine it. People can judge whether the AI is on the right track and stop it if not, which saves them time and saves you compute.
A worked example: the "Summarise report" button
Here is the same feature, designed twice.
Before
- Person clicks "Summarise".
- Button stays the same. A spinner appears in the middle of the page.
- Nothing changes for 15 to 40 seconds.
- The full summary appears all at once.
After
| Moment | What the person sees |
|---|---|
| Before the click | Button reads "Summarise (about 20 seconds)" |
| 0 to 0.1 s | Button changes to "Summarising…" and becomes disabled, so a second click is impossible |
| Under 1 s | A summary panel opens with a skeleton of three short paragraphs |
| 1 to 5 s | Status line: "Reading 14 pages" |
| From about 5 s | The first sentence streams into the panel, word by word |
| Throughout | A "Stop" link sits next to the status line |
| End | Status line becomes "Done. Based on pages 1 to 14", with "Regenerate" and "Copy" buttons |
The model did not get faster. The person now knows, at every moment, that it is working, roughly what it is doing and what they can do about it.
Microcopy you can copy
Small words carry a lot of this. Here are some starting points. Change them to match what your system really does.
| Situation | Weak | Better |
|---|---|---|
| Just clicked | "Loading…" | "Starting your summary…" |
| Working on a known step | "Thinking…" | "Reading your 3 files" |
| Long job | "Please wait" | "This usually takes about a minute. You can keep working." |
| Taking longer than usual | (nothing) | "Still working. Longer documents take more time." |
| Failed | "Error" | "That took too long and stopped. Try again, or try a shorter section." |
Try this today
- Time your slowest AI feature five times with a phone stopwatch. Write down the shortest and longest wait. That range tells you which indicator from the ladder you need.
- Make sure the button changes within a tenth of a second of the click and cannot be pressed twice.
- If the feature returns text, check whether your AI provider supports streaming, and turn it on.
- Replace any static "Loading…" or "Thinking…" with a line that names the real step.
- Add a visible Stop button to anything that can run longer than 10 seconds.
Sources
- Response Times: The 3 Important Limits, Jakob Nielsen, Nielsen Norman Group (1993)
- 10 Usability Heuristics for User Interface Design, Jakob Nielsen, Nielsen Norman Group (1994)
- Progress Indicators Make a Slow System Less Insufferable, Katie Sherwin, Nielsen Norman Group (2014)
- Skeleton Screens 101, Samhita Tankala, Nielsen Norman Group (2023)
- Streaming Messages, Anthropic documentation
- Explainability + Trust, People + AI Guidebook, Google PAIR
More in UI-UX
UI-UX
Accessibility is UX: 10 quick fixes that help every user
Most websites still fail basic accessibility checks. Here are 10 fixes, each tied to its WCAG 2.2 rule, that you can make this week and that help every visitor.
UI-UX
Onboarding that keeps users: the first 60 seconds of an app
Most new users decide fast whether an app is worth keeping. Here is how to spend the first minute: skip the tour, delay sign-up and get people to one real win.
UI-UX
Chat is not always the answer: when a button beats a prompt box
A prompt box looks flexible, but it asks people to know what to type. Here is a simple test for when a button, menu or slider serves users better than chat.