The processing screen, and what it claims

A rating tool's waiting screen tells you almost nothing: its scripted steps and feature counts are copy timed to the display, not a report on work being done. "Uploading," "analysing," "scoring" is broadly true. "Analysing 27 features..." with a number attached is where it stops being a description and starts being copy.

Why the number is invented

There is no reason to expect a model actually computes a discrete, countable set of 27 anything, and no reason the product would show you the real count if it did - internal representations do not map cleanly onto a small integer a marketing team can put on a loading screen. The specific number exists because a specific number reads as more technical than a vague phrase like "analysing image," not because 27 is a figure anyone checked against the pipeline.

What is not happening during the wait

The wait is not the model taking longer to be more careful. It is not a queue of sequential checks running one after another in the order the copy implies. Most of the actual computation finishes well before the screen has cycled through its scripted phrases, which means the phrases are timed to the display, not to the work - a fixed-length animation dressed as a status update. Usability research is clear about what a wait costs: Jakob Nielsen (1993, Nielsen Norman Group) puts 1 second as "the limit for the user's flow of thought to stay uninterrupted" and 10 seconds as the limit for keeping attention on the task, so padding a finished result to fit a script spends attention for show.

The rotating-phrase trick specifically

A screen that cycles through several lines - "checking symmetry," "comparing proportions," "finalising score" - is doing something slightly different from a single spinner: it is implying a pipeline with discrete, ordered stages, each one presumably taking its own slice of the wait. Most of the time no such ordered pipeline is visible to a user in any way that corresponds to the phrases; the lines are timed to divide the artificial delay evenly, not to report on work actually completing in that sequence. If the delay were removed entirely, the same computation would still finish, just without the four captions describing steps that took no measurable time relative to each other.

Where the real processing lives

If you want to know what genuinely happens to an uploaded photo before a number comes out - what kind of model, what it is doing with the pixels - that is a different subject with its own owner. How the model actually processes an image covers the real mechanism; this site's interest stops at what the waiting screen tells you, which is mostly nothing.

What to ignore

Ignore the specific claims - the feature count, the named steps, the implied thoroughness. None of it is verifiable from the outside, and none of it should raise or lower your confidence in the number that eventually appears. The waiting screen's only honest function is a loading indicator; everything past "please wait" is written to make the eventual result feel more earned than a sub-second API call actually earns, and it is one of several presentation elements worth reading past on the way to the actual number.

This is a different mechanism from what happens after the number is ready. The reveal animation manufactures suspense once the result exists; the waiting screen manufactures the appearance of depth while it does not yet exist, and a page that runs both is applying the same trick twice, once on each side of the number's arrival.

The honest version

A results page that shows a plain spinner and a short wait is not doing less work than one with an elaborate feature-count animation - it is simply not spending design effort convincing you otherwise. Rate Cock keeps its processing screen minimal for exactly this reason: there is nothing to communicate about internal steps that the reader can verify, so it does not invent language that implies otherwise.

The comparison worth keeping in mind: on the measurement side of the category, a reported figure comes with an actual method attached that a person followed and could describe if asked, which is a different kind of claim from a loading screen's list of steps nobody performed in that order. And a human judge's response genuinely does take real time for a real reason, which is worth remembering the next time an automated countdown tries to borrow that credibility for a computation that finished in under a second.