The Deliberately Slow Subsystem: A Defense of Strategic Jank
We have been indoctrinated. The dogma of front-end performance is clear: every millisecond matters, every layout shift is a sin, and a jank-free experience is the ultimate sign of craft. Our metrics—Cumulative Layout Shift, Total Blocking Time—are the new scriptures, and we are the devout, furiously optimizing, preloading, and deferring to appease them. But what if our pursuit of seamless, instantaneous perfection is not just exhausting, but actually robbing our interfaces of something vital? What if, in some very specific cases, a little bit of deliberate, controlled friction is exactly what a user needs?
I’m not arguing for sloppiness. I’m arguing for intentionality. Consider the humble toggle switch, or a complex settings panel. The common advice is to make its state change instant—a binary visual flip governed by a CSS transition so fast it’s nearly subliminal. This is optimal for the machine. But for the human, that instantaneous flip can be disorienting. Did it work? Did I even click it? The action and its confirmation collapse into a single, forgettable event.
Now, imagine that same toggle. You click it. There's a purposeful, 200-millisecond delay—a tiny, tactile ‘click’ sensation in the UI—before the switch completes its throw and a subtle, cascading reflow adjusts the surrounding options panel. That delay is ‘jank’ by the purest definition. It’s blocking, it’s not fully painted in a single frame. But it’s also communication. It transforms a binary input into a miniature narrative: action, acknowledgment, consequence. The slight, sequential layout shift becomes a visual highlight, guiding the eye to what changed because of the user’s command. It says, “Your action mattered here.”
Optimizing for Perception, Not Stopwatches
Our performance orthodoxy optimizes for the stopwatch, but humans perceive speed through causality and confidence, not just raw duration. A loading bar that moves predictably feels faster than a quicker, but sporadic, progression. Similarly, a UI that visually ‘works’ in direct, understandable response to input feels more responsive than one that magic-swaps states, leaving the user to verify the result.
This is the counterintuitive core: sometimes, to make an interface feel faster and more solid, we must design a subsystem that is technically slower and less stable. We must steal a few milliseconds from the Main Thread, not to waste them, but to spend them as a budget for clarity. That budget pays for a micro-interaction’s staging, for a transition that elucidates rather than merely animates, for a layout shift that teaches rather than frustrates.
The craft, then, shifts. Instead of an unbending quest to eliminate all blocking time and all layout instability, our challenge becomes one of precise allocation and choreography. Where do we invest our precious, ‘slow’ milliseconds for maximum perceptual return? It’s a design performance budget, not just a technical one. It asks us to understand that ‘jank’ applied indiscriminately is a failure of engineering, but ‘jank’ applied with surgical precision—or rather, its deliberate, theatrical cousin, ‘pause’—can be a tool of profound communication. Perhaps it's time we stopped treating every hiccup in the renderer as a bug, and started recognizing some of them as carefully placed punctuation in a conversation with a person.
Notes & further reading
A few pages I came back to while writing this: