Nobody is at fault during a loading screen, which is exactly why it can afford a joke

What it is

Legitimate positions for interface humor are not equal: waiting scenes — progress pages, downloads, migrations, large-file processing — carry humor far better than error scenes. In a wait no one is at fault: the system has not failed, the user has done nothing wrong, and both parties are stuck with the same third-party fact. The safety precondition humor needs holds here by default and collapses by default at the moment of error; ordered along that axis, waiting sits at the far friendly end and error-and-loss at the other.

Why it happens

Waiting holds two things humor needs, and error scenes lack both. The first is a no-fault party: nobody has lost anything, no offense has been cashed in, and the joke can aim at something no one blames — the oversized file, the slow network, the queuing server. The second is an attention surplus: the operation is committed, the task is temporarily closed to the user, hands and working memory are idle, so building and resolving a joke competes with no goal — reading it is a gain, missing it a loss of nothing. Error scenes invert both: negative affect is present and blame is undecided (whose fault is not yet settled), so a quip reads either as not taking it seriously or as taking sides on the blame question; cognition is meanwhile occupied by loss processing and recovery planning, leaving no bandwidth to unwrap a punchline. Waiting pays a third dividend: system and user are, unusually, pulling the same direction — both waiting on the same file — so joking about that shared thing produces alliance, converting the ordeal into a shared "stuck here together" instead of an adversarial "you are wasting my time." This also explains why perceived waiting time shrinks in an amusing wait: attention held by company content is attention unavailable to the mental clock.

Where it stops holding

The ordering flips first on stakes: once the wait hangs real consequences on the user — payment processing, a non-reversible submission — the low-stakes premise is gone; the mind carries a load and the joke reads as frivolous. Second, time pressure: a hurried user's goal-directed attention comes back online, the wait turns from idle time back into an obstacle, and humor becomes its competitor again. Third, the most overlooked condition: humor's safety presupposes that "this really is a wait" — if the progress bar ends in failure, every prior quip is retroactively flipped into "making a joke of my time," so wait-page humor must stand on honest progress information. Finally, wait humor accompanies short-to-medium waits only; the repetition decay of the same gag across a very long wait is a separate failure mode outside this remedy.

Applying it

• List progress pages, downloads, migrations, first loading, and large-file import/export as humor's legitimate positions; default to none elsewhere.
• Fix the wait-page information order: current state → estimated time or progress → a cancel affordance; humor comes after these three as company content, displacing none of them.
• Aim the joke at the shared situation (this file, this network, this server), not at the user's choices nor at the system's incompetence.
• No humor in unskippable waits (forced migrations, non-cancellable processing) — company without an exit becomes compulsory entertainment.
• To validate: run the same wait page with and without humor and compare abandonment rate and subjective duration ratings; keep it only if abandonment does not rise and perceived duration does not stretch.

Related

• Same group: P1.12.1 Humor may target only the system, never the user · P1.12.3 Humor degrades the information in the same copy · P1.12.4 Humor that cannot be localized turns into noise after translation
• Nearby: P1.06.1 Jokes do not belong in error and loss scenarios · T2.10 Microcopy placement
• Search terms: psychology of waiting · perceived waiting time · unoccupied time · voice and tone