An interface never carries its own reasons.

In 2007 four researchers sat twenty-two people in front of pairs of progress bars and asked which one was faster. Every bar took exactly 5.5 seconds. A third of the time people called it a tie. The rest of the time they picked a winner, and the same ones kept winning.

What moved the answer was the shape of the function behind the bar. Bars that paused felt slow. Bars that accelerated felt fast. Both effects got much stronger near the end, and the two functions judged faster than linear were the ones making most of their progress in the last stretch. The paper is Rethinking the Progress Bar, at UIST, and it reads the result against Fredrickson and Kahneman on duration neglect: people rate an experience by its peak and its ending, with the length barely counting.

Now take that finding and use it. What lands in the code is a curve, four numbers long. A year later it is just four numbers.

The reasons were always somewhere else

Fitts published his law in 1954: the time to hit a target is a function of the ratio between how far away it is and how wide it is. A screen edge stops the pointer, so a target pressed against one behaves as if it extended forever and cannot be overshot. The four corners are the easiest pixels on a display, because two edges stop the pointer at once. A menu that opens under the cursor sits at distance zero.

A toolbar pinned to the edge of a window looks exactly the same whether the person who put it there derived it from a 1954 paper or copied it from the last app they used. The screen has no field for which one it was.

The same holds for time. Miller measured response thresholds in 1968 and Card in 1991, and they have held since: a tenth of a second reads as instant, one second keeps a thought unbroken, ten seconds loses the person. In a codebase the path that answers a keystroke and the path that answers a save look alike. One of them has to return inside that tenth of a second, or the character stops feeling like it was caused by the key. The other has a full second, which is how long a person can wait and still be holding the same thought. The line between them was measured before the personal computer existed. Nothing in the file says which is which.

Or take what happens past the end of a list. Bounce-back is the default in Apple's scroll views and in Safari on the phone; Android answers the same question by stretching the content at the edge, and a desktop browser mostly declines to answer it. The question is how to tell the person scrolling that the list ended, so that a screen that has stopped moving does not read as a screen that has frozen. The motion is the part that got copied from product to product. The question it answers is not attached to it.

Convention and craft are the same shape

Everything a model knows about interfaces came from artifacts, and an artifact almost never carries its provenance. So the model cannot tell a reasoned shape from a copied one. Neither can the next designer on the project, looking at the same screenshot.

That is a large part of why generated interface work reads as plausible and hollow at once. What arrives is the right shape without the reason, and the reason was the only thing that made the shape right here. Convention is a form that has outlived the argument for it. Most of what any of us ship is convention, which is fine, and it carries most of the value.

The bill arrives when a form gets carried into a context it was never reasoned for. A 400ms transition that is a pleasure once per session is unbearable at once per keystroke. A bounce at the end of a list tells you the list ended, and on a pane that scrolls one screen it tells you nothing you did not already know. The form is identical on both sides. Only the reason says which side you are on. None of that is new. What changed is the cost of carrying a form somewhere it does not belong: it used to be the hours of rebuilding it, and hours are a filter. Now it is a sentence.

What that asks of the work

Not more documentation. Documentation explains a system to a reader who came to understand it. The reason has to reach a reader who came to change one line: attached to the decision, in a form that holds up for somebody who was not there when it was made.

Two kinds of reason are worth the effort. A measurement, because it settles an argument nobody can settle by looking. And a rejection, because a decision is mostly the options that lost, and those leave no trace anywhere else. Everything past those two is preference, and preference should be left for the next competent pass to normalize away.

An interface has never carried its own reasons. That cost almost nothing for as long as the reasons stayed in the people who made it, and those people were still there when it changed. The thing that changes it now was not in the room.