I can add RAM to the box in the basement. I did it last month. I cannot add RAM to the person looking at the screen, and no release will ever ship that changes it.

That’s the whole field in one sentence. Every other part of the stack has gotten exponentially better — storage, bandwidth, inference, the number of pixels I can push at a wrist — and the thing on the receiving end has a working memory that hasn’t been revised since the Pleistocene and doesn’t take patches.

So when you pour more data through the pipe, you’re not scaling. You’re overdrawing an account that belongs to somebody else.

And overdrawing it isn’t abstract. It shows up as a person who missed the thing that mattered, confirmed a dialog without reading it, and closed your app annoyed without ever being able to tell you why.

Cognitive load splits three ways, and the split is useful because only one of them is your fault.

Intrinsic — the task is genuinely hard. Comparing mortgage rates is hard. Reading a multivariable health dashboard is hard. You can’t design this away; you can only cut it into pieces a person can swallow one at a time.

Germane — the effort of actually learning your thing. Building the mental model that makes the next visit fast. This one is an investment and you want to protect it.

Extraneous — pure overhead you inflicted. Inconsistent labels. Six-point type. Two buttons competing to be the primary action. Nothing about this load helps anyone do anything.

Here’s the part that reframed it for me. These three draw from the same pool. Extraneous load doesn’t just annoy people — it starves the intrinsic task. Every milligram of attention someone spends decoding your inconsistent navigation is attention that is no longer available for the actual decision they came to make.

A cluttered interface doesn’t make your product feel bad. It makes your user worse at the thing they came to do, and they will experience that as their own failure.

It gets sharper with age. Sensory and memory decline don’t just make dense layouts harder to read — they push visual complexity past working-memory capacity faster, so the same screen that’s merely busy at 25 is genuinely exhausting at 70.

Now the number that made me want to write this.

Researchers put data visualizations on smartwatches and measured how long a human needs to make a basic comparison. Not to enjoy the chart. To extract one fact.

donut chart        159 – 220 ms     ✅ recommended
bar chart          245 – 300 ms     ✅ recommended
radial bar chart  1548 – 1780 ms    ❌ not recommended

A donut is read in about a sixth of a second. A radial bar chart — the beautiful one, the concentric arcs, the one that wins the dribbble shot and gets screenshotted into a design system — takes nearly two full seconds.

That’s an order of magnitude. Same data, same screen, same person. The only variable is which geometry you picked.

And it collides with the other number in this literature: most smartwatch interactions are glances under five seconds. Often much less. Somebody lifts a wrist mid-stride, gets an answer, drops it.

So a radial bar chart doesn’t cost 1.5 seconds. It costs a third of the entire interaction budget, spent on decoding the chart rather than learning anything — and that’s if the person is standing still. Under motion, accuracy drops further, and linear encodings beat radial ones consistently, because the visual system tracks length far better than it tracks swept angle while your head is bouncing.

The corollary is the finding I liked most in the whole pile: runners reading a visualization complete the task 1.5 to 8 times faster than runners reading the same value as a number. Text is not the neutral baseline. Text is a chart that hasn’t been drawn yet.

Two laws, both old, both routinely ignored by people who have read them.

Hick’s Law: decision time grows logarithmically with the number of options. Every choice you add taxes every choice already there.

Fitts’s Law: effort scales with target size and distance. Which on a phone becomes a physical fact about the human hand — the thumb zone, the arc a thumb sweeps without regripping.

Elements inside natural thumb reach get about 80% more interaction than elements outside it. Not 8%. Eighty.

Which means vertical position on a phone is not layout. It’s a multiplier on whether anything happens at all. Put your primary action in the top-right of a 6.7-inch screen and you have built a button that requires a hand adjustment to press, and most people will simply not do it — and it will read in your analytics as low intent rather than as bad ergonomics.

Floor on touch targets: 44×44 pt on iOS, 48 dp on Android. Below that you’re not designing compactly, you’re manufacturing misfires and calling them user error.

Progressive disclosure — Nielsen, 1995, older than most of the frameworks arguing about it — is just: show the minimum for right now, keep the rest one deliberate step away. Three flavors:

• Sequential — cut one monstrous workflow into linear stages. Multi-step checkout. Progressive registration. Same total work, dramatically higher completion, because a person can see the end of each piece.
• Conditional — advanced settings stay folded until asked for. Accordions, tabs, the “Advanced” toggle. Novices aren’t intimidated; experts still get depth.
• Contextual — surface things based on what the user already did. Search that narrows as you type. Transfer options that appear once a payee is valid.

Notion hides its database engine until you’ve got the confidence to want it. Airtable opens as a spreadsheet — a thing everyone already knows — and only later admits it’s also Kanban, calendar, and timeline.

Then the escalation: zero-decision UX. Not fewer options — fewer decisions. Smart defaults that make the educated guess so the human doesn’t spend a decision on it. Prefill the city from the postcode. Default the departure airport to where they actually are.

With a knife-edge attached: a wrong default costs more than no default. Auto-fill someone’s home airport while they’re on vacation booking a flight home and you haven’t saved a decision, you’ve created a bug the user has to find and undo.

And the boundary that separates this from the dark side: a smart default is trivially reversible and stated plainly. A pre-checked subscription box is also a “default,” and it’s theft. The mechanism is identical. Only the intent differs, which is exactly why it’s worth naming.

Optical zoom is affine: multiply the geometry, get bigger pixels. Zoom out on a dense network graph and you get an unreadable hairball of overlapping four-point labels.

Semantic zoom changes the kind of information, not its size:

• Macro — aggregate. Grouped bars, regional heatmaps, logical clusters. No labels, because labels are noise at this altitude.
• Meso — structure. Group boundaries firm up, prominent nodes take iconic form.
• Micro — detail. Text labels, individual points, exact values.

The load-bearing constraint is geometric stability: once something has a position, it keeps it at every depth. That’s what makes zoom navigation instead of teleportation. Break it and you strand the user — they zoom in expecting the thing they saw, and arrive somewhere unrecognizable.

It’s real engineering, not a metaphor. Genomics tools swap a stacked distribution chart for literal nucleotide labels past a base-pair threshold. Windows’ SemanticZoom control binds a grouped view and an item view to one source so panning stays coherent across the jump. 3D code-city visualizers redraw building detail by camera distance so a large codebase doesn’t render as visual static.

Same instinct as the tri-tier reducer I built for ScholarSync, honestly: don’t collapse a complex structure into one view. Give it altitudes, and keep the map registered between them.

Here’s the part that’s either the best or worst news in the file, depending on your disposition.

Cognitive fatigue used to be measured by asking — NASA-TLX, the Mental Fatigue Scale, self-report. Now it can be measured by watching, with the front camera already in the phone.

Fatigued gaze degrades in specific, quantifiable ways. Gaze error — distance between where you’re looking and where the target is — grows in mean, in standard deviation, and in entropy. Rested eyes track smoothly. Tired eyes deviate, saccade erratically, and blink in bursts.

From 75-second chunks of gaze data, classifiers predict mental fatigue at up to 80% accuracy, AUC 0.818–0.833 — beating task-performance metrics. Pupil diameter tracks time-on-task in real time.

Which means an interface can now know you’re tired before you do, and adapt: simplify the view, drop a tier of density, make the primary action heavier when your eyes start wandering.

It also means an interface can know you’re tired before you do. Same sentence. Fatigue detection is a feature when it defends attention and a weapon when it targets the exact moment your judgment thins. The literature is about the first. Nothing in the technology enforces it.

I’d want that computation on-device, discarded after the window, and never sold. I don’t expect that to be the default. I expect the first mainstream deployment to be an ad system that learns when you’re too tired to say no.

Every technique here is the same move: put the work on the machine, which is elastic, instead of the human, who is not.

Progressive disclosure moves sequencing effort out of the user’s head into the interface. Smart defaults move decisions from the person to the system. Semantic zoom moves aggregation from the eye to the renderer. Glanceable geometry moves comparison from arithmetic to perception. Gaze telemetry moves fatigue-monitoring from self-report to sensor.

None of it is about making software look simple. Simple-looking software that hides state is worse — it just relocates the confusion to somewhere you can’t see it. It’s about spending a scarce, non-renewable, borrowed resource carefully.

I keep landing in this same place from different directions. A memory system that shouldn’t dump four tiers into a prompt with equal weight, because a pile is not an answer. A research engine that shouldn’t flatten seventy papers into one confident paragraph. An OS README that shouldn’t list nine capabilities when six are real.

All three are the same failure as a radial bar chart: taking something the machine could have resolved, and handing it to a human as work.

The screen got smaller and it made the arithmetic obvious. Sixteen years of desktop monitors let us hide the cost, because there was always more room to put another panel. On a watch face there is no room, and every unnecessary element is visibly stealing from a five-second budget.