Every design framework in the canon is a sentence. Two of them are equations — and equations are the only thing an agent can evaluate without judgment.
Hypothesis
If the hypothesis holds, an agent can audit layout for interaction cost using only measurements it already takes: getBoundingClientRect() for geometry, querySelectorAll() for choice counts. This is the follow-through on the agent-computability survey from 08-04, which graded Fitts’s and Hick’s as the only “A” frameworks — the rest demand semantic judgment. The primary thesis criterion — what criteria can agents use? — becomes answerable: “better” is a function an agent can call. The secondary criterion — what can agents perceive? — is already satisfied. The qualitative frameworks form the control group: they should produce zero numbers from DOM measurements.
Method
Fitts’s Law, from psychologist Paul Fitts’s 1954 work, states time to reach a target grows with distance D and shrinks with target width W. We use the standard HCI form T = a + b·log2(D/W + 1). Mailchimp’s worked example writes the sibling form MT = a + b·log2(2D/W) — same constants, the +1 just lands in a different spot — and supplies the regression constants a=200ms, b=100ms/bit. Hick’s Law, per the Hick-Hyman reference, says decision time scales logarithmically with choice count n.
// Fitts: movement time to a target in ms. Constants a=200ms, b=100ms/bit
// from regression (Mailchimp's worked example). D = distance from pointer
// start to target center, W = target width — both from bounding-box geometry.
function fitts(el, pointerStart = { x: innerWidth / 2, y: innerHeight / 2 }) {
const r = el.getBoundingClientRect();
const D = Math.hypot(
r.left + r.width / 2 - pointerStart.x,
r.top + r.height / 2 - pointerStart.y
);
const W = r.width;
return 200 + 100 * Math.log2(D / W + 1); // ms
}
// Hick: decision bits for n equally-prominent choices.
const hickBits = (n) => Math.log2(n + 1);Fitts measurement: rect = el.getBoundingClientRect(); W = rect.width; D = Euclidean distance from pointer start (viewport center as the agent’s honest default, or last focused element) to rect center. Hick measurement: n = count of top-level choices via document.querySelectorAll('nav a') at the same hierarchy level.
Results
Fitts, baseline: D=500px, W=100px, a=200ms, b=100ms/bit → log2(500/100 + 1) = log2(6) ≈ 2.585 → T ≈ 459 ms.
Doubling width (W=200px): log2(3.5) ≈ 1.807 → T ≈ 381 ms (−78 ms). Halving distance (D=250px, W=100px): same ≈ 381 ms (−78 ms). Halving distance and doubling width each save exactly one bit — the law makes distance and size trade against each other in a single unit an agent can price.
Hick: n=7 → log2(8) = 3 bits; n=15 → log2(16) = 4 bits. Doubling the menu from 7 to 15 items adds exactly one bit. The logarithmic curve is why choice count matters less than choice structure, and why the seven-item ceiling is the right agent threshold.
Control group: Gestalt principles describe perception but prescribe no measurable target; Nielsen’s heuristics and the ux247 variant are checklists without arithmetic; C.R.A.P. principles demand visual judgment; Design Thinking is a process, not a metric; Jobs-to-be-Done requires reading user intent. None produce a number from DOM measurements — hypothesis contrast confirmed.
Conclusion
The single computable rule: for every interactive element, rect = el.getBoundingClientRect(); W = rect.width; H = rect.height; FAIL if min(W,H) < 24 CSS px (WCAG 2.2 SC 2.5.8 AA); WARN if min(W,H) < 44 CSS px. For each primary CTA: D = distance from viewport center to rect center; cost = log2(D/W + 1) bits; flag any CTA with cost > 3.3 bits. Count top-level nav choices n; flag if n > 7. Regenerate on any FAIL; prefer shrinking D over shrinking W, and grouping choices over adding nav items. Agents learn to design better when “better” is a function they can call. The frameworks that fail the arithmetic test are mentors, not linters — they teach judgment, but they cannot grade it. These numbers also give an agent a stopping rule: once doubling the target or halving the distance stops buying a measurable bit, the layout has converged, and further regen cycles add cost, not quality. The arithmetic turns iteration from guesswork into a bounded search: the agent can justify every regen round in its own log and stop when the bit budget is spent.