Fitts’s Law: Big and Near Beats Small and Far

Summary: Pointing time depends on two numbers: target distance and target size. Paul Fitts quantified this in 1954, explaining every mouse move and thumb tap since then. Make frequent targets big and near, make destructive ones small and far, and don’t supersize everything else. The law holds up in VR and AR, at degraded throughput. And AI doesn’t repeal it; it merely shrinks pointing’s kingdom as conversation replaces cascades of clicks. The humans working beside robots still follow Fitts’s Law, so robots must act accordingly.

Definition: Fitts’s Law states that the time to acquire a target grows with its distance (D) and shrinks with its width (W): movement time MT = a + b log₂(2D/W). The log term is the index of difficulty, measured in bits, a nod to Claude Shannon’s information theory (1948).

Example: Moving 512 pixels to a 32-pixel button = log₂(32) = 5 bits of difficulty; doubling the button to 64 pixels shaves off exactly 1 bit.

The logarithm rewards proportional changes. Every doubling removes the same 1 bit in this formulation, but each later doubling consumes more pixels. Growing an icon from 5 to 10 pixels, therefore, buys far more speed per pixel than growing a button from 100 to 200: both design changes save the same time, but the second requires 20x as many additional pixels.

Tiny targets are the cardinal sin. Merely modest ones are usually fine. Every undersized button levies a target tax: a few hundred milliseconds extorted from every user, on every click, forever.

Tiny buttons and other touch targets are the cardinal sin of ignoring Fitts’s Law. (Muse Image)

From Cockpit Errors to Cursor Movements

Paul Fitts was an aviation psychologist who spent World War II documenting how “pilot error” was usually designer error: identical levers for flaps and landing gear, side by side. In 1954, at Ohio State University, he had subjects tap a stylus between two metal plates; movement time followed his logarithmic tradeoff with eerie regularity. His subjects pushed roughly 10 bits per second through their arms, a figure Fitts treated as the information capacity of the human motor system. (He also ran disc-transfer and pin-transfer variants, in case you suspected the plates were a fluke. They weren’t.)

When a plane crashed, who was to blame? Traditionally, investigations concluded that most crashes were due to pilot error, because the pilot had used the wrong control for the situation. Since the pilot was usually dead in the worst crashes, the case was closed. Fitts anticipated my basic rule of usability by several decades: when the user does something wrong, it’s the designer’s fault, because the UI was designed to be error-prone.

The law reached computing in 1978, when Stuart Card, William English, and Betty Burr at Xerox PARC raced the mouse against joysticks and cursor keys. The mouse won, obeyed the equation beautifully, and earned its place on the Xerox Star and the 1984 Macintosh.

Xerox PARC scientists measured the speed of selecting on-screen targets with various pointing devices. The mouse won.

Scott MacKenzie’s refined formulation (1992) remains the standard model in HCI research, and the ISO 9241-411 standard turned the law into the field’s measuring stick: pointing devices are graded by throughput in bits per second, with a correction that resizes targets to the accuracy users actually delivered. A desktop mouse scores 3.7–4.9 bits/s (PDF). Not bad for a 72-year-old equation.

Why a Logarithm? Blame Your Noisy Muscles

Why should precision cost logarithmic time? Because an aimed movement is a feedback loop. The classic account, formalized by Crossman and Goodeve in 1963 (and not published until 1983, academia being what it is), splits each reach into a fast ballistic burst followed by corrective nibbles, with every correction fixing a roughly constant fraction of the remaining error. Halving the error takes one correction; halving it again takes another. So landing within tolerance W from distance D costs a logarithmic number of corrections. David Meyer and co-authors refined the idea into the optimized-submovement model in 1988, with the same punchline.

The deeper culprit is signal-dependent noise: the motor system’s output noise grows with the size of the command. Move fast, and your muscles shout; shouting adds static. Misaki Takeda and colleagues at the Nagaoka University of Technology showed in 2019 that Fitts’s slope and intercept can be derived from arm inertia, joint mechanics, and that noise, with no information theory required. Your arm is a noisy amplifier, and the logarithm is the bill for quieting it. Hold that thought for when the robots arrive: their amplifiers don’t shout.

An interface should be a test nobody fails. If a control matters, it belongs in the big top rows, not down in the fine print.

Spend Pixels, Save Milliseconds

Pixels are cheap; user time isn’t. So spend the former to buy the latter. Make the whole element clickable: when a list row shows an icon, a title, and 300 pixels of padding, all of it should accept the click, not just the 11-character link. (I’ve harped on this since the 1990s. Evidently, my persuasion coefficient is smaller than Fitts’s b.)

Geometry is a statement of design intent: what the company wants you to do is big and easy. But it’s a dark design pattern to make the user’s escape options tiny.

Fingers raise the stakes. A fingertip occludes what it’s about to touch, and its contact patch wobbles from tap to tap, adding an absolute noise floor that pixel math doesn’t predict. Xiaojun Bi and colleagues at Google formalized this as the “FFitts” law: once targets shrink toward finger scale, misses pile up faster than the classic equation promises. Hence the familiar floors: Apple’s 44 points, Google’s 48 dp, and my 1 × 1 cm. All are minimums, not aspirations.

A target’s usability depends partly on its neighbors. A 48 dp button bordered by empty space is safer than the same button pressed against another action, because the same slip of the finger turns a harmless miss into the wrong action. On touchscreens, size and spacing are therefore complementary design variables. The practical question is not only “Can the finger land on this?” but “What happens when it lands just outside?”

Simple guidelines for making the click/tap area large enough.

Shrink the Distance to Zero

The other half of the equation is D, and the best D is zero. Why do right-click menus feel so fast? Because they open at the pointer: D ≈ 0, and the log term evaporates. Like Mjölnir returning to Thor’s hand, the control comes to you. The same logic powers pie menus (every option equidistant, and direction becomes muscle memory), the mini toolbar that materializes beside a text selection, and inline editing instead of a round trip to a settings page.

In Norse mythology, the thunder god Thor’s hammer Mjölnir flew back to his hand after every throw. Thor never had to reach for it and thus escaped Fitts’s Law: the target came to wherever his open hand was. (Muse Image)

Next best: exploit screen edges. The cursor stops there, making edge targets effectively infinitely deep, so users can slam the mouse without overshooting. That’s why the Mac menu bar hugs the top of the screen and the Start button sits in a corner, the strongest position of all, since a corner is infinitely deep in two directions. (Windows 95 inset that button a couple of pixels from the corner, breaking the trick; later versions fixed it. Nice work, eventually.)

Cascading dropdowns obey a crueler cousin of the law: Johnny Accot and Shumin Zhai’s steering law (1997) shows that steering through a tunnel costs time in proportion to length over width, which is why threading a 20-pixel-tall submenu corridor feels like parallel parking. Amazon’s classic mega-dropdown fixed it with a hover triangle: move diagonally toward the submenu, and the menu forgives the grazed neighbors along the way. Forgiveness is a Fitts feature.

If you can make the clickable item come to where the cursor (or finger) already is, your user will feel like mighty Thor. Almost as good, though only on desktop: place the action in a corner or at a screen edge, where the mouse can’t overshoot the target.

Cheat Codes: Gravity Wells, Bubble Cursors, and Growing Buttons

Software can also rig the race. Pointer acceleration shortens effective distance on long hauls. Sticky targets and gravity wells fatten effective width by slowing the cursor inside a button. Tovi Grossman and Ravin Balakrishnan’s bubble cursor (2005) goes further: it always selects the nearest target, so each object’s effective width balloons to fill the empty space around it, and pointing in sparse layouts approaches teleportation.

Growing buttons work, too: the same lab showed that a target expanding even after 90% of the movement is complete still speeds acquisition. (The macOS Dock’s magnification is the famous example, with an asterisk: as icons swell, their neighbors slide aside, so the Dock giveth width and taketh away position.)

Make the target expand while the cursor is still on the way.

The ultimate cheat is to leave the equation entirely. The best pointing is no pointing. Remember that sentence; it returns shortly, when AI eliminates much of today’s pointing.

Reprogramming GUI elements to “undermine” Fitts’s Law is fair play, as long as targets get faster to acquire. Computers exist to serve humans, after all.

When Fitts’s Law Backfires

But motor time isn’t usability. Fitts’s Law models the hand, not the eye or the brain, and misapplying it hurts in three predictable ways:

• Supersizing everything. When every element balloons, information density collapses, distances grow, and scrolling explodes. If everything is big, nothing is near.

• Billboard buttons. A button styled like an ad triggers banner blindness: users skip it during visual search, and no motor efficiency rescues an unseen target.

• Fast access to disaster. Placing Delete adjacent to Reply minimizes distance and maximizes catastrophe.

Three common ways to misapply Fitts’s Law.

The law is also silent about finding and choosing. Visual search runs on its own clock, and decision time follows Hick’s Law (1952): more choices, slower picks. Fitts’s stopwatch starts only after the eye has located the target and the brain has committed to it. A design that wins milliseconds of motor time by losing seconds of search time has made a sucker’s trade.

Fitts’s Law describes a single target acquisition. Product design must optimize a whole sequence of acquisitions and their errors. The relevant quantity is expected human cost: acquisition time multiplied by frequency, plus error probability multiplied by error damage. A frequent, reversible action earns space because tiny gains compound. A rare, irreversible action needs more than a small hit area: it needs separation, explicit intent, and recovery. Optimize the stream, not the isolated click.

One platform caveat: on touchscreens, edges aren’t magic (there’s no cursor to pin), and the far corners of a 6.7-inch phone are the thumb’s Siberia.

12 Fitts-Based Design Guidelines

1.          Make touch targets at least 1 × 1 cm. Apple specifies 44 points and Google 48 dp; treat both as floors.

2.          Go bigger for older users. Task performance drops about 0.8% per year of age, and motor precision declines with it.

3.          Make the entire visual element clickable, including all padding and whitespace.

4.          Put frequent controls where the pointer already is: context menus, inline editing, toolbars beside their content.

5.          Pin desktop power targets to screen edges and corners, where the cursor can’t overshoot. (Desktop only: edges do nothing for thumbs.)

6.          Cluster controls used in sequence so each movement stays short.

Controls that users click in sequence belong close together, so that each hop from one to the next stays short.

7.          Apply the law in reverse for destructive actions: small, distant, and never adjacent to high-frequency buttons.

8.          Enlarge only the primary action on each screen. One hero button per view; the rest just clear the minimum.

9.          Forgive the diagonal. Give cascading menus a hover-intent delay or an Amazon-style triangle, so users can cut across empty space without losing the submenu.

10.      Keep targets where users left them. Stable positions let repeated acquisitions run on muscle memory: a wizard’s Next button should sit in the same spot on every step. And never let late-loading content shift a button underneath a descending finger.

For a sequence of steps, it’s positively evil to move the “Next” button between steps. Leave it in one place.

11.      Offer a no-pointing path for frequent actions. Keyboard shortcuts, Enter to submit, and sensible defaults spare practiced users the tax entirely.

12.      Design for the shakiest hand in your audience. Tremor, motor impairments, and bumpy commutes all shrink effective precision; generous targets are an accessibility feature first and a convenience second.

Follow these 12 guidelines, and Fitts’s Law starts working for your users instead of against them.

Same Law, Worse Numbers: Fitts in VR and AR

Strap on a headset, and Fitts’s Law follows you inside. Mohammadreza Amini and co-authors reviewed 119 publications covering 122 user studies of Fitts’s Law in 3D extended reality (XR = VR or AR). The law transfers, with adaptations: for ray casting (waving a laser pointer at floating UI), angular variants of the equation apply, because what matters is the angle a target subtends at your hand, not its size in centimeters. The numbers, though, should humble every XR enthusiast. Median selection time across studies is 1.25 seconds, with a 12% error rate and a throughput of 3.25 bits/s, versus 3.7–4.9 bits/s for the lowly desktop mouse. A desktop app where every eighth click missed would be declared broken. In a headset, it’s the state of the art. (To be fair to the field: XR pointing research is a triumph of measurement. The medium remains an ergonomic work in progress.)

In extended reality, the arm becomes the mouse: expressive, elegant, and a worse pointing device than the rodent it replaced.

Depth is the villain. Selecting along the depth axis is slower and less accurate than lateral movement, partly because of the vergence–accommodation conflict: your eyes converge on the virtual target while focusing on the fixed display, a disagreement your visual system files under “headache.” Yet 45% of the reviewed studies didn’t even report target depth, one of several methodological sins the authors catalog. More than half the studies invoked Fitts’s Law without measuring throughput, movement time, or error rate by the book. The paper closes with a checklist for doing it right; if you run XR studies, adopt it.

Fitts’s Law still holds for pointing in virtual reality or augmented reality (together: extended reality, or XR), but throughput falls well below that of a mouse on a desktop monitor.

For designers, the practical takeaway: size XR targets in visual angle, not meters. Park frequent controls at a constant, comfortable depth (body-anchored panels beat world-anchored ones). Keep task difficulty inside the 2–3 bit range where the evidence lives. And steal the 2D cheat codes, because snapping and bubble-style selection port to 3D nicely; ray casting plus a forgiving snap radius is the Mac menu bar of XR, an edge where none existed. Above all, remember that the user’s arm is now the mouse. An arm is a worse mouse, and it’s attached to an aching shoulder.

Headset selection today: 1.25 seconds per pick and every eighth one a miss. That’s pointing at drive-in-intermission pace, so design for arms that tire.

AI Shrinks the Kingdom of Pointing

Count what a classic GUI task actually costs. The keystroke-level model (Card, Moran, and Newell, 1980) budgets roughly 1.1 seconds per pointing act, plus homing between keyboard and mouse, plus a mental pause before each step. Now run “turn off notifications during meetings” as a GUI task: Settings, then search or scroll, then Notifications, then Focus, then a schedule screen, then a toggle, then Save. That’s 7 target acquisitions, each taxed by Fitts, wrapped in navigation: a click commute. Half a century of GUI craft has been the micro-tuning of those hops.

One sentence of intent replaces a continent of menus. Nobody misses that commute.

Conversational AI vaporizes the hops. One sentence, typed or spoken, states the goal, and the system does the walking: intent-based outcome specification instead of command-by-command steering. Speech input runs about 3 times faster than typing on phones (Sherry Ruan at Stanford and co-authors measured the 3x factor for both English and Mandarin), and either modality beats a 7-hop pointing safari. D and W simply exit the core task. For the first time since the GUI went mainstream in 1984, the ascendant interaction technique isn’t a Fitts task.

AI converts many pointing tasks into spoken or typed intent. But GUI operations survive in a diminished role, so Fitts’s Law stays with us.

But the time doesn’t vanish; it migrates. You now pay to formulate intent, to wait for generation, and above all to check the result. Clicking overhead becomes verification overhead: reading the AI’s output, at a stately 250 words per minute, is the new pointing. So the optimization target shifts from time-to-acquire-a-target to time-to-a-verified-outcome. An AI feature that saves 8 seconds of clicking but demands 40 seconds of proofreading is a net loss, and no button enlargement will rescue it.

The classical route to one setting is a 7-stage contraption. Conversational AI scraps the machine and replaces it with a single sentence.

And Fitts still governs the frame around the conversation. Send buttons, microphone toggles, suggestion chips, and Accept vs. Reject on inline edits are all targets. Tab-to-accept an autocompletion is pure Fitts wisdom (D = 0, W = a key your finger already rests on), which is why it feels like telepathy. Errors change species, though: the misclick becomes the misunderstanding. A misclick costs 200 milliseconds. A misunderstanding costs a repair dialog, and occasionally a confidently wrong slide deck.

AI Trades Spatial Distance for Semantic Distance

Conversation removes the distance between the pointer and the control, but introduces a different distance: the gap between the user’s goal and the words needed to specify it, AKA the articulation barrier. A GUI externalizes available actions and current state; chat asks users to recall what can be requested and compress goals, constraints, and exceptions into language. When the request is underspecified, the missing distance reappears as a round of clarifying questions.

The strongest AI interface is therefore a hybrid. Use language to declare intent, and use visible controls to inspect state, compare alternatives, set exact parameters, and repair a local error without restating the whole request. Chat for intent; GUI for state. The best pointing is no pointing, but the best interface is not no interface.

AI as an Invisible Fitts Optimizer

AI was optimizing Fitts’s variables before the current boom made AI fashionable. Your iPhone keyboard has resized its keys invisibly since 2007: the painted keys never change, but the touch zones beneath them grow and shrink with every keystroke, following a language model’s guess at your next letter (Apple patented the trick). After you type “q,” the invisible “u” becomes enormous. That’s W turned probabilistic and re-optimized several times per second, and nobody notices, which is exactly the point.

Prediction can enlarge W, but only within a risk budget. Inflating the likely next letter is benign because errors are cheap, visible, and reversible. Inflating Send, Buy, Approve, or Delete is different. AI should enlarge invisible hit regions only when confidence is high, the action is easy to undo, and nearby alternatives keep their own territory. Invisible assistance should absorb harmless misses and never manufacture consequential ones.

The same move generalizes: AI can inflate effective targets through smarter snapping, gaze-plus-intent fusion in XR, and predictive cursor capture. But there’s a bright line, and the adaptive UIs of the past crossed it with a flourish: resize invisibly; relocate never. When Office 2000’s “personalized” menus rearranged themselves around usage frequency, they converted every user’s muscle memory into a scavenger hunt, and the feature died unmourned. A target that moves is a target reacquired from scratch. AI should make targets easier to hit, never harder to find.

Agents Turn Target Acquisition into Trust Calibration

Agentic AI goes further: you don’t operate the interface; you delegate to software that does. Interaction becomes episodic. Minutes of autonomous work, punctuated by checkpoints: review the plan, inspect the changes, approve the purchase. Pointing time rounds to zero in that accounting. The scarce resources are attention and calibrated trust, and the cognitive-load budget of supervision replaces the motor budget of operation.

Yet the few clicks that remain are the heaviest clicks in computing. “Approve” now launches actions with real-world consequences, which turns Fitts’s Law into a safety tool used in reverse. Consequential approvals deserve anti-targets: controls engineered to be hard to hit, through added distance, reduced size, a typed confirmation, or a deliberate pause. (Slide-to-unlock was an anti-target; so is typing DELETE to drop a database.)

The user’s coat of arms for the agentic age: “delegate and verify” is our new motto.

The catastrophic-adjacency rule returns with higher stakes: a big, friendly “Approve all” beside a granular review list is the agentic era’s Delete-next-to-Reply. Tilt the asymmetry toward recovery instead: pausing the agent must be the easiest target on the screen, and undo the second-easiest. When software can act 1,000 times while you blink, the stop control has to work like an emergency brake.

AI reduces the number of clicks but raises the stakes of each one.

My prediction: within 5 years, the knowledge worker’s daily click count falls by half while the stakes of the average surviving click double. Budget your Fitts care accordingly.

Do Robots Obey Fitts’s Law?

Here’s the question I find most interesting as AI grows a body: does the law bind the robots themselves? Is a big, nearby object faster for a robot to acquire, the way it is for you? The answer splits cleanly in two.

When a human steers, yes. Teleoperation keeps a nervous system in the loop, so Fitts’s Law holds, and roboticists use it as a benchmark. Jiahe Pan and colleagues at the University of Melbourne ran a Fitts-style target ring through a haptic controller driving a robot arm and found that the index of difficulty predicted both performance and the operator’s cognitive load across robot-assistance levels, making the index of difficulty a tuning knob for how much help the robot should give. Latency is the poison: MacKenzie and Ware showed in 1993 that lag compounds with difficulty, wrecking throughput at delays well under half a second, which every surgeon on a teleoperation console (and every gamer on hotel Wi-Fi) can confirm. Physical collaboration obeys, too: Kyle Reed and colleagues at Northwestern found (PDF) that 2 people jointly turning a shared crank follow Fitts’s Law and finish faster than either person alone. The law scales to teams.

When the robot acts alone, mostly no. An industrial arm’s motion time comes from trajectory planning under velocity and acceleration caps: accelerate, cruise, brake, the classic trapezoidal speed profile. Time grows roughly linearly with distance, and target size barely matters, because a calibrated arm repeats its positioning to within ±0.02–0.1 mm (per manufacturer datasheets), a tolerance about 100 times finer than any button humans design. Recall why you pay the logarithm: signal-dependent noise, muscles that get sloppier as they push harder. Servo motors don’t shout. A robot has no yips. So for robots, “near” helps somewhat (and linearly), while “big” is nearly free. On long hauls, distance actually costs a robot relatively more than it costs you (your ballistic burst covers most of any distance in one throw, while the robot’s cruise speed is capped), and precision costs it nearly nothing. Until uncertainty enters.

Robots move without the jitters of human muscles: straight to the target, hitting it precisely every time, within a tenth of a millimeter.

Uncertainty resurrects the law. Take away the robot’s perfect knowledge of where things are, and the logarithm returns, sometimes with interest. Visual servoing, the standard technique by which a robot homes in on a target it sees rather than knows, drives the position error down exponentially, so settling within tolerance W from offset D takes time proportional to log(D/W): Fitts’s ratio, derived from control theory (PDF; Chaumette and Hutchinson’s classic tutorial) instead of psychology. Crossman and Goodeve’s iterative-corrections account of human reaching, reborn in steel.

And with tight tolerances, robots fare worse than the human logarithm: peg-in-hole insertion under positional uncertainty forces spiral search strategies whose duration balloons as clearance shrinks. A home robot fishing your keys from a cluttered drawer pays its precision tax in perception and grasp planning rather than in muscle noise. Fitts’s Law is the price of acting under uncertainty, and robots pay it exactly when they’re unsure.

Different actors have different limitations.

The Robot Should Pay the Target Tax

For usability, the deciding fact isn’t whether robots obey Fitts’s Law. It’s that the humans around them always will. Every handover, every shared workbench, every hallway negotiation with a delivery robot is a pointing task performed by human muscles under the old logarithmic rules. So design embodied AI the way you’d design a good GUI: spend the machine’s cheap resources to save the human’s expensive ones. The robot’s centimeters cost linear milliseconds; your precision costs logarithmic ones. Let the robot pay the target tax. It gets a volume discount.

• Come to the human, then hold still. Kyle Strabala and co-authors mapped the where, when, and how (PDF) of human handovers to teach robots the same protocol. The practical core: deliver the object into comfortable reach and hold it stable in a grasp-friendly pose. That’s minimal D and maximal effective W for the person. A handover on the move is a moving target, and moving targets get harder with speed. Stop, then offer.

• Move legibly. Anca Dragan and colleagues at Carnegie Mellon showed (PDF) that motion revealing its goal early lets bystanders predict a robot’s target and plan their own movements around it. An efficient-but-opaque trajectory forces everyone nearby into wait-and-see mode, inflating their reaction and correction times. Legibility buys back the milliseconds that mystery steals.

• Accept that safety inverts the law. Under the ISO/TS 15066 rules for collaborative robots, speed-and-separation monitoring throttles the machine as people approach. For you, being near the target makes you fast; for a robot, being near you makes it slow. Safety envelopes are anti-targets at room scale: zones engineered to be hard to enter, marked by light curtains and projected floor graphics.

Safety inverts the law: the closer a robot gets to a human, the slower it must move.

• Fix the rendezvous points. A robot that always docks, delivers, and waits at the same spots lets human muscle memory do its zero-thought magic, the physical version of guideline 10.

• Funnel the human’s aim. Big handles, chamfered docks, and wide drop zones are hardware’s version of snapping and gravity wells. Tolerant geometry forgives imprecise reaches, and the forgiving party should always be the machine.

• Make stopping the easiest act in the room. The ISO 13850 emergency stop, a giant red mushroom on a yellow field, slappable with a palm from anywhere, is maximal W, minimal D, and zero required precision. Safety engineers solved the most important pointing problem decades before UX had a name. As AI gets a body, keep it solved: the emergency stop is the one target that must never charge a tax.

Let the robot do the extra reaching, so that the humans around it don’t have to.

4 Scales of Fitts-Based Design

Fitts-based design now operates at 4 scales. At the control scale, enlarge the hitbox. At the screen scale, bring the control to the locus of attention. At the workflow scale, remove whole acquisitions with language and automation. At the embodied scale, make the machine move so the person doesn’t have to. The equation stays the same; the design leverage keeps expanding.

Conclusion: The Last Target Standing

Fitts’s Law is the closest thing UX has to a law of physics: 72 years old, replicated endlessly, and violated daily by 8-pixel icons. The fix costs nothing but pixels. This week, audit your product’s top 5 tasks, measure the smallest frequent target, and refund the target tax. Users pay it in milliseconds; you pay it in conversions.

Then look ahead. AI will keep shrinking pointing’s share of the interaction, and that’s progress: the best pointing is no pointing. But the clicks that survive grow heavier: approve, verify, pause, stop. Design those few targets with all the care Fitts’s old equation demands, and when your product grows wheels and a gripper, make it pick up the tab: the robot should pay the target tax so that the humans around it don’t have to. The last target standing in the age of embodied AI is a big red button on a factory wall, huge, near, and impossible to miss. That one, we got right the first time.

Stop taxing every click. The big red one rides free.

(All images in this article made with GPT Image 2, unless otherwise indicated.)