Stop Treating a Spinner as a Default: Design Loading Feedback by How Long the Wait Is
The choice between a spinner and a skeleton screen is not a styling decision; it is a forecast about duration, and the popular claim that skeletons feel faster does not survive the controlled tests. This article argues that loading feedback should be selected from the expected wait length and whether progress is computable, that the skeleton's reliable benefit is layout stability rather than perceived speed, and that every indeterminate state needs a timeout to a real error.
Series: agentic-ai (4 articles)
- …
- 4Stop Treating a Spinner as a Default: Design Loading Feedback by How Long the Wait Is This article
- A static busy icon hides the state that matters
A spinner is an indeterminate indicator. It says the system is working and nothing else — not how much is done, not how long remains, and not whether the process has hung. That last ambiguity is the oldest documented problem. In his 1985 CHI paper, Brad Myers pointed out that a static busy picture such as an hourglass cannot distinguish a fast task from a slow one or a crashed process, whereas a percent-done indicator freezes when the program stops updating, which tells the user the process is no longer running [1].
Myers ran a formal experiment with 48 subjects performing the same database-query tasks with and without a progress indicator. The preference for having one was strong and statistically significant (p = 0.0006), and 86.1% of subjects said they liked the indicator, with a mean usefulness rating of 2.94 on a scale where 1 meant "very useful" and 9 meant "useless, annoying" [1]. The paper is also honest about a hypothesis that failed. It set out to show that people prefer constant over variable response times and that a progress indicator would reverse that preference, but the constant-versus-variable difference was not statistically significant, contradicting earlier published results [1]. Treat the progress bar's popularity as well-supported and the finer claims about response-time variability as unsettled even in the founding study.
- The skeleton's perceived-speed win is contested
Around 2013, Luke Wroblewski argued that spinners draw attention to the wait itself and proposed skeleton screens that preview the incoming layout instead. That argument came from observational feedback on one application rather than a controlled comparison [2]. The best-known controlled experiment points the other way. In 2017, Viget ran a study with 136 participants who waited identical durations behind a spinner, a skeleton, or a blank screen. The skeleton lost on every measured metric: fewer skeleton users agreed the content "loaded quickly" (59% versus 74% for the spinner), and their estimated wait was longer (2.82 seconds versus 2.41 seconds) [2]. The authors flagged the limits directly — small study, one interface, short waits — and suggested skeletons may suit familiar layouts seen loading before, with genuinely short waits.
Later work nudges the result back without settling it. Two rounds of testing by Bill Chung, with 80 in-person and 80 remote participants, found skeletons modestly ahead, while noting the advantage was minor and most production "skeletons" are really static splash screens. A separate ECCE 2018 study by Mejtoft and colleagues found the skeleton version scored higher on average for perceived speed, yet first-time visitors using the spinner found the target article faster [2]. Add these together and the defensible reading is plain: no study has shown a large, reliable perceived-speed win for either pattern, the samples are all small, and the direction depends on familiarity and wait length. Anyone citing a fixed figure such as "skeletons feel 30% faster" is repeating a number with no traceable source.
- The skeleton's real value is measured, not felt
There is one argument for skeletons that does not depend on subjective perception. A skeleton that matches the final layout reserves the correct space, so content does not jump when it arrives. That is cumulative layout shift, a Core Web Vital that Google scores directly, and avoiding it is a concrete, measurable win regardless of whether anyone feels the page is faster [5]. The precondition is that the skeleton must mirror the real components — same card dimensions, line counts, and image aspect ratios. A skeleton that reserves the wrong heights both lies about the incoming page and still shifts the layout, which is the worst of both options.
- Pick the feedback from the duration
The thresholds descend from Jakob Nielsen's long-standing response-time limits, which he traces to human-factors work by Robert Miller in 1968: roughly 0.1 seconds feels instantaneous, 1 second keeps a user's train of thought unbroken, and 10 seconds is the outer edge of holding attention [3]. These are heuristics from an older era of computing, not constants, so use them as bands rather than exact cutoffs. A peer-reviewed CHI study on system response delays confirms the underlying direction with a modern method, showing that delays measurably reduce user engagement in a crowdsourced task [4].

Figure by the author (illustrative).
- A loading-state contract
Expected wait | What to show | Engineering requirement |
|---|---|---|
Under ~0.1 s | Nothing | Render the result directly; no indicator |
~0.1–1 s | Nothing, or a delayed indicator | Mount the indicator on a 300–500 ms timer so fast responses show no loading UI |
~1–10 s | Skeleton for familiar content layouts, spinner for actions and unfamiliar screens | Match real geometry; set a minimum display time so the indicator never flickers |
Over ~10 s | Determinate progress plus a cancel affordance | Show a percentage, step name, or count that visibly advances |
Two implementation rules sit across the table. The first is the delayed indicator. A spinner that flashes for 150 milliseconds and vanishes reads as a glitch, so wait a few hundred milliseconds before showing anything and enforce a minimum display time once it appears. The second is the determinate fallback. "Step 2 of 4" or a real percentage beats any shimmer the moment you can compute it; skeletons and spinners are what you use when you genuinely cannot know progress, not the goal.
- Accessibility and the failure path
An infinite shimmer is ambient motion, and some users enable reduced-motion settings specifically to avoid it. Honor
prefers-reduced-motion by dropping the animation; a static gray placeholder still communicates loading [6]. Mark the region for assistive technology with aria-busy="true" and clear it when content lands, since a skeleton is invisible to a screen reader. Most importantly, a skeleton has no failure mode of its own. If the request fails and nothing replaces it, the user stares at shimmering bones indefinitely, which is worse than an honest error. Every loading state needs a timeout — around the ten-to-fifteen-second edge — that resolves to a real error state with a retry action.
Next steps: stop asking "skeleton or spinner" as a matter of taste. Estimate the expected wait, then follow the duration table. Delay the indicator, prefer determinate progress whenever you can compute it, build skeletons that mirror the real layout to protect against layout shift, and wire a timeout to an error state for every path. Feed measured actual waits back so the thresholds reflect your own users rather than a 1960s baseline.
References
- Myers, "The Importance of Percent-Done Progress Indicators for Computer-Human Interfaces," CHI '85 (n = 48; p = 0.0006; 86.1% preference; constant vs variable not significant) — https://dl.acm.org/doi/pdf/10.1145/1165385.317459
- "Skeleton Screens vs. Spinners: What Loading States Actually Do to Perceived Speed" (reporting Viget 2017, n = 136; Chung 2018; Mejtoft et al. ECCE 2018) — https://lunchboxhands.com/blog/skeleton-screens-vs-spinners/
- Nielsen Norman Group, "Response Times: The 3 Important Limits" (thresholds traced to Miller, 1968) — https://www.nngroup.com/articles/response-times-3-important-limits/
- "Using Crowd Sourcing to Measure the Effects of System Response Delays on User Engagement," CHI 2016 — https://dl.acm.org/doi/pdf/10.1145/2858036.2858572
- web.dev, "Cumulative Layout Shift (CLS)" (Core Web Vital) — https://web.dev/articles/cls
- MDN Web Docs, "prefers-reduced-motion" — https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-reduced-motion
Series: agentic-ai (4 articles)
- …
- 4Stop Treating a Spinner as a Default: Design Loading Feedback by How Long the Wait Is This article
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article