Touch-Target Miss¶

Reclassify a mistyped tap from operator error to interface defect by reading the miss rate off the mismatch between a control's target geometry and the operator population's motor precision — a geometric scan Fitts's Law makes quantitative.

Core Idea¶

A touch-target miss is the human-computer interaction failure mode in which an interactive control's effective target area — its minimum dimension, the spacing between it and adjacent targets, and its placement relative to the operator's natural reach — is mismatched to the motor precision and reach characteristics of the intended operator population under the expected operating conditions, so that the operator's touch or pointer input lands outside the programmatically responsive region with enough frequency to degrade task performance, cause accidental activation of adjacent controls, or exclude users at the low-precision tail of the population altogether. The structural mismatch is between input target geometry (minimum tap dimension, center-to-center spacing, target position in the reachable zone) and human motor capability (accuracy, reach envelope, stability) — a mismatch that Fitts's Law quantifies: movement time to acquire a target is logarithmic in the ratio of distance to target width, so smaller, closer-together, or more distant targets impose more time and more error. The failure has three components that interface reviews routinely conflate: the visible target (the rendered affordance the operator aims at), the hit area (the programmatically responsive region, which can be larger or smaller than the visible target and is a design choice), and the operator precision distribution including its low-precision tail (users with motor impairment, tremor, gloves, physical instability, or degraded conditions such as motion or low light). A touch-target miss is classified as an interface defect rather than operator error when the geometry guarantees a non-trivial miss rate across the expected operator population: an operator in degraded motor conditions was always going to miss a 32×32 pixel button with 4 pixels of spacing, regardless of skill or attention. Published guidance codifies remedies: Apple HIG and Google Material Design specify minimum 44×44 point touch targets with at least 8 points spacing; WCAG 2.5.8 specifies 24×24 CSS pixels minimum; FDA human-factors guidance requires that medical-device controls be sized and spaced for the user population's motor characteristics. The full intervention family — enlarge the hit area beyond the visible target, increase spacing, relocate controls to the reachable zone, add confirmation dialogs for irreversible adjacent controls, design for the low-precision tail — addresses the geometry without requiring changes to operator behavior or training.

Structural Signature¶

Sig role-phrases:

the visible target — the rendered affordance the operator aims at
the hit area — the programmatically responsive region, which can be larger or smaller than the visible target and is an independent design lever
the input target geometry — the control's minimum tap dimension, center-to-center spacing from adjacent targets, and position in the reachable zone
the operator precision distribution — the intended population's motor accuracy, reach envelope, and stability, including its low-precision tail (tremor, motor impairment, gloves)
the operating context — the expected conditions (motion, low light, awkward posture) that degrade effective precision
the geometric mismatch — the failure driver: target dimension or spacing below what the operator-precision-under-conditions requires, which Fitts's Law makes quantitative (acquisition time logarithmic in distance/width)
the miss outcome — input landing outside the responsive region with enough frequency to degrade performance, trigger adjacent controls, or exclude the low-precision tail entirely
the defect classification — the rule that a geometry-guaranteed non-trivial miss rate across the population is an interface defect, not operator error (the gloved nurse was always going to miss the 32×32 button)
the geometry-only fix family — remedies confined to the mismatch: enlarge the hit area, increase spacing, relocate to the reachable zone, guard irreversible adjacent controls, design for the low-precision tail — none touching operator training

What It Is Not¶

Not operator error. When the geometry guarantees a non-trivial miss rate across the expected population, the event is an interface defect, not a user slip — a gloved nurse in low light was always going to miss a 32×32 pixel button with 4 pixels of spacing, regardless of skill or attention. Logging it as "user tapped the wrong control" mislocates the fault and points the remedy at training, which cannot move a geometrically-determined error rate.
Not the same as the visible target. The hit area — the programmatically responsive region — need not coincide with the rendered affordance the operator aims at, and that they can differ is itself a design lever: the hit area can be enlarged beyond the visible button to catch near-misses without redrawing the layout. Treating the drawn target and the responsive region as one misses an independent control on the miss rate.
Not fixable by training or attention. The miss rate is fixed by the dimension-versus-precision mismatch, so only operations on the geometry move it — enlarge the hit area, widen spacing, relocate to the reachable zone, guard irreversible adjacent controls. Exhorting operators to be more careful is inert against an error rate the geometry determines.
Not a verdict for the steady-handed user. The question is not "does it work?" but "does it work across the operator-precision distribution, including its low-precision tail — tremor, motor impairment, gloves, motion, low light?" A 44-point target adequate for a steady-handed adult can be impossible for someone with essential tremor, so the design must be evaluated against the worst expected condition, not the best.
Not a substrate-spanning failure mode under its own name. The concept carries the touchscreen-and-finger apparatus visibly — the visible-target/hit-area distinction, the sizing thresholds, the operator-precision tail. Its quantitative core is Fitts's Law (a sibling HCI entry), and the cross-domain concern (an effector's precision mismatched to its target's geometry — CEP, tolerance stacks, instrument resolution) is the resolution-matching parent, each with its own native math. "Touch-target miss" does not strip cleanly to that pattern; applied beyond touch interfaces it is analogy.

Scope of Application¶

The touch-target miss lives within human-computer interaction, accessibility, and touch-device design — one substrate (fingertip/pointer acquisition of designed targets by an operator population) at many device types; its reach is bounded there (its quantitative core is the sibling HCI entry Fitts's Law), and the cross-domain effector-vs-target-geometry concern (CEP, tolerance stacks, instrument resolution) belongs to the parent resolution-matching pattern with its own native math, not to this name.

Mobile and web UI — the home turf, where the design guidance (Apple HIG and Material 44×44-point targets with 8-point spacing, WCAG 2.5.8's 24 CSS pixels) is codified.
Accessibility engineering — designing for the low-precision tail of the operator population (tremor, motor impairment, gloves, motion), where the geometric scan is the audit method.
Public kiosks and voting machines — high-stakes single-session interfaces where a geometry-guaranteed miss rate excludes or misdirects users.
Medical-device interfaces — infusion pumps and bedside medication systems under FDA human-factors guidance, where adjacent-control activation can cause harm.
Control-room and vehicle panels — touch and pointer controls operated under motion, awkward posture, or time pressure, where reach-zone placement and spacing govern error.

Clarity¶

Naming the touch-target miss does its sharpest work by relocating fault from the operator to the geometry. An interface log that records "user tapped the wrong control" frames the event as operator error — a slip to be fixed by training or attention. The concept reframes it as an interface defect whenever the geometry guarantees a non-trivial miss rate across the expected population: a gloved nurse in low light was always going to miss a 32×32 pixel button with 4 pixels of spacing, no matter how skilled or careful. That reclassification is consequential because it redirects the entire remedy — away from blaming or retraining the operator and toward changing the dimensions, which is the only thing that can move a miss rate the operator's behavior cannot.

The concept also sharpens two distinctions that interface reviews routinely collapse. First, visible target versus hit area: the rendered affordance the operator aims at and the programmatically responsive region need not coincide, and that they can differ is itself a design lever — the hit area can be enlarged beyond the visible button to catch near-misses without redrawing the layout. Second, it forces the operator-precision distribution, including its low-precision tail, into view: a 44-point target adequate for a steady-handed adult is impossible for someone with essential tremor, so "does it work?" becomes "does it work across the population's precision range, including users with impairment, gloves, or motion?" Holding these apart lets a reviewer audit an interface as a geometric scan — minimum dimension, center-to-center spacing, position in the reachable zone, against published thresholds — rather than as an impression of usability, and to ask the load-bearing question: is the target sized for the worst expected operating conditions, not the best?

Manages Complexity¶

An interface usability review confronts an open-ended set of failure reports — wrong control tapped, accidental activation, fatigue, a user who cannot operate the screen at all — each arriving with its own narrative of operator skill, attention, conditions, and intent, and each ordinarily adjudicated as a judgment call about whether the human or the design was at fault. Touch-target miss compresses that sprawl by recognizing that, for any interactive control, the miss rate is fixed by a small geometric mismatch — between input target geometry (minimum tap dimension, center-to-center spacing, position in the reachable zone) and the operator precision distribution (accuracy, reach, stability, and its low-precision tail) under the expected conditions — and that Fitts's Law makes the relationship quantitative: acquisition time and error scale with the ratio of distance to target width. The reviewer therefore stops adjudicating reports one by one and instead extracts, per control, a few measurable quantities — minimum dimension, spacing, reach position, worst expected operating condition — and reads the qualitative outcome off a comparison to published thresholds (44×44 points with 8-point spacing, WCAG's 24 CSS pixels, the population's precision range). A long, subjective usability review collapses to a short geometric scan. The compression carries the fault-attribution branch with it, replacing case-by-case judgment with a rule: where the geometry guarantees a non-trivial miss rate across the expected population, the event is an interface defect, not operator error — a gloved nurse in low light was always going to miss a 32×32 button with 4 pixels of spacing — and that classification is read directly off the geometry-versus-precision comparison rather than from the operator's skill or care. It also fixes the small set of distinctions the review must hold, again as parameters rather than impressions: the visible target and the hit area are separated so the responsive region can be enlarged beyond the rendered button as an independent lever, and the precision distribution is forced into view so the verdict is "works across the population's range, including impairment, gloves, and motion," not "works for a steady hand." Because the outcome is read off geometry, the remedy is determined by the same parameters and is confined to them — enlarge the hit area, widen spacing, relocate to the reachable zone, guard irreversible adjacent controls, design for the low-precision tail — none of which touches operator behavior or training, the lever the miss rate does not respond to. So a heterogeneous stream of usability complaints reduces to tracking target dimension, spacing, reach, and the operator-precision tail per control, with the defect classification and the corrective intervention both read off that small geometric comparison instead of re-litigated report by report.

Abstract Reasoning¶

A touch-target miss licenses reasoning moves an interface reviewer or designer runs on any interactive control, all conducted on the mismatch between input target geometry (minimum tap dimension, center-to-center spacing, position in the reachable zone) and the operator precision distribution (accuracy, reach, stability, and its low-precision tail) under the expected operating conditions.

The fault-attribution move is the sharpest: it reclassifies an apparent operator error as an interface defect by reasoning from the geometry. Confronting a log entry that reads "user tapped the wrong control," the reviewer does not accept it as a slip to be trained away but asks whether the geometry guarantees a non-trivial miss rate across the expected population — and if it does, attributes the fault to the design. The inference runs from the dimensions plus the worst expected operating condition to a verdict about culpability: a gloved nurse in low light was always going to miss a 32×32 pixel button with 4 pixels of spacing, regardless of skill or attention, so the event is an interface defect. The consequence the move forces is that the remedy must change the geometry, because the miss rate is the one quantity operator behavior cannot move; blaming or retraining the user is reasoned to be inert against a geometrically-determined error rate.

The predictive move uses Fitts's Law to forecast acquisition time and error from the geometry. The reviewer reasons that movement time to acquire a target is logarithmic in the ratio of distance to target width, so smaller, more closely spaced, or more distant targets are predicted to impose more time and more error — a quantitative forecast from dimensions rather than a usability impression. This lets the reviewer rank controls by expected miss rate, predict which adjacent-control activations will occur (a small target beside an irreversible control predicts accidental triggering of the irreversible one), and estimate how much a dimensional change will improve performance before building it.

The boundary-drawing move separates three things interface reviews conflate, and reasons about each as an independent lever or parameter. Visible target versus hit area: the rendered affordance and the programmatically responsive region need not coincide, so the reviewer treats the hit area as a lever that can be enlarged beyond the visible button to catch near-misses without redrawing the layout — a move that improves the miss rate while leaving the visual design untouched. And the operator precision distribution including its low-precision tail: the reviewer refuses the question "does it work?" in favor of "does it work across the population's precision range, including users with tremor, gloves, motion, or low light?", reasoning that a 44-point target adequate for a steady-handed adult is impossible for someone with essential tremor, so the design must be evaluated against the worst expected condition, not the best. This converts the review from an impression into a geometric scan — extract minimum dimension, spacing, and reach position per control, compare to published thresholds (44×44 points with 8-point spacing, WCAG's 24 CSS pixels) — and reasons the verdict off the comparison.

The interventionist move confines the remedy to the geometry, because the outcome was read off the geometry. Having located the defect in the dimension-versus-precision mismatch, the reviewer predicts that only operations on that mismatch will move the miss rate: enlarge the hit area beyond the visible target, increase spacing, relocate controls into the reachable zone, add a confirmation step for irreversible controls adjacent to frequently-tapped ones, and design explicitly for the low-precision tail. Each is reasoned as a movement on a specific geometric parameter with a predicted effect on miss rate, and the move's discipline is that none of them touches operator behavior or training — the lever that the miss rate, by the fault-attribution reasoning, does not respond to.

Knowledge Transfer¶

Within HCI, accessibility, and device design the failure mode transfers as mechanism, and what carries is the whole apparatus: the input-geometry-versus-operator-precision mismatch as the unit of analysis, the visible-target/hit-area separation as an independent lever, the fault-attribution rule (geometry-guaranteed miss rate = interface defect, not operator error), the Fitts's-Law prediction of acquisition time and error, and the geometry-only intervention family. The precondition is a designed interface taking touch or pointer input from an operator population under expected conditions, and across device types each is a genuine instance of the same mismatch rather than a likeness — touchscreens, public kiosks, voting machines, infusion pumps and bedside medication systems, and control-room panels. The transfer is mechanism-preserving because these are one substrate — fingertip/pointer acquisition of designed targets — at many device scales, so the geometric scan, the defect classification, and the remedy carry intact, with the published thresholds (44×44 points with 8-point spacing, WCAG's 24 CSS pixels, FDA human-factors sizing) applying across them.

Beyond HCI the report points up rather than out, and the boundary is sharp because the name carries the touchscreen-and-finger apparatus visibly. (1) The same concern — an effector's precision mismatched to the geometry of the target it must hit — is real across many domains, but each has its own native framing and substrate-specific math: surgical tools too coarse for the structure being operated on, a munition's circular error probable exceeding the target size, a joystick deadzone larger than the maneuver, a pipette volume below the substance's heterogeneity scale, a sensor footprint larger than the feature being sensed. Applying "touch-target miss" to any of these is analogy — it borrows the mismatch shape while dropping the touch-input geometry and the operator-precision-distribution apparatus that give the original its content, and it should be marked as such, because the concept does not strip cleanly to the broader pattern. (2) What genuinely recurs across those domains, as mechanism rather than metaphor, is one level up: the general pattern of resolution matching — match an instrument's or effector's resolution to the precision the task requires. That parent really does travel as a co-instance relation, and CEP, tolerance stacks, instrument resolution, and pipette/sensor footprint are its instances under their own names, not exports of touch-target miss. So the cross-domain lesson should carry the parent resolution-matching pattern, while touch-target miss's distinctive cargo (the visible-target/hit-area distinction, the touchscreen sizing thresholds, the operator-population precision tail with gloves/tremor/motion/low-light, the HCI intervention family) is human-computer-interaction furniture that does not and should not travel. A closely related honesty: the quantitative core of the concept is Fitts's Law, which already lives as a sibling HCI domain-specific entry — touch-target miss is the failure-mode framing of that same content — so within the domain the portable quantitative form is Fitts, and across domains the portable structure is resolution matching, neither of which is the named touch-target-miss. Mechanism within HCI/touch-device design (one substrate at many device types); a shared abstract pattern — carried by the resolution-matching parent (with each domain's own native math), not this named failure mode — beyond. This is exactly the boundary Structural Core vs. Domain Accent draws.

Examples¶

Canonical¶

The concept's quantitative core is Fitts's Law, MT = a + b·log₂(2D/W), where the index of difficulty ID = log₂(2D/W) rises as a target of width W sits farther away (distance D) or shrinks. Take two buttons the same distance D = 200 px from the finger's start, one at the platform-guideline width W = 44 pt and one at the accessibility-floor width W = 24 px. For the 44-unit target, ID = log₂(2·200/44) = log₂(9.09) ≈ 3.18 bits; for the 24-unit target, ID = log₂(2·200/24) = log₂(16.67) ≈ 4.06 bits. The smaller target's higher index of difficulty predicts more acquisition time and more error, quantitatively, from geometry alone. A 32×32 px button with 4 px spacing pushes ID higher still and guarantees a non-trivial miss rate for anyone in the low-precision tail — which is why it is scored an interface defect, not a user slip.

Mapped back: W, D, and the 4 px spacing are the input target geometry; the gap between a 44-unit and a 24-unit target is the geometric mismatch that Fitts's Law makes quantitative. The higher ID predicting more misses is the miss outcome forecast from dimensions, and the 32×32 button's guaranteed miss rate is the defect classification in action.

Applied / In Practice¶

Infusion-pump interfaces are a high-stakes field deployment of this reasoning. Programming a pump requires clinicians to enter drug doses on small keypads or touchscreens, often under time pressure and sometimes gloved, and mis-taps that select an adjacent key or the wrong control have caused dangerous dosing errors. After a wave of such incidents, the U.S. FDA's Infusion Pump Improvement Initiative (2010) and its human-factors guidance pushed manufacturers to size and space controls for the clinical user population and operating conditions, rather than treating the errors as careless nursing. The remedies were geometric and procedural: larger, better-spaced controls, confirmation steps for irreversible dose changes, and layouts that separate frequently used keys from destructive ones — none of which relies on retraining the operator.

Mapped back: Clinicians working fast and gloved are the operator precision distribution under a demanding operating context, and undersized keypad controls are the input target geometry producing the miss outcome of adjacent-control activation. Reclassifying dosing mis-taps from nurse error to design fault is the defect classification, and larger spacing plus confirmation guards are the geometry-only fix family.

Structural Tensions¶

T1: Interface defect versus operator error (the reclassification dial cuts both ways). The concept's sharpest move relocates fault from the operator to the geometry whenever the dimensions guarantee a non-trivial miss rate — the gloved nurse was always going to miss the 32×32 button. That correction is vital, but the line between a geometry-guaranteed miss and a genuine operator slip is not always clean: some misses reflect a target the geometry made unhittable, others reflect attention lapses, haste, or errors a hittable target still admits. Push the dial all the way to "always the design" and genuinely operator-remediable problems (and the residual errors no geometry eliminates) get absolved and left unaddressed; leave it at "always the user" and real defects get logged as slips. The reclassification is powerful precisely because it reassigns culpability, which is exactly why over-applying it in either direction mis-locates the fix. Diagnostic: Does the geometry guarantee this miss rate across the population (interface defect), or would a properly sized target have been hittable and the miss reflects a residual operator factor that geometry cannot remove?

T2: Hit area beyond the visible target versus the invisible boundary (the miss-catching lever manufactures false activations). Separating the hit area from the visible target lets a designer enlarge the responsive region past the drawn button to catch near-misses without redrawing the layout — a clean win on the miss rate. But the enlarged hit area is invisible: the operator sees the rendered affordance, not the true active boundary, so taps the user believes land outside the control now activate it, and adjacent enlarged hit areas can overlap and steal each other's taps. The lever that reduces misses of the intended target simultaneously produces false activations of it and blurs where one control ends and the next begins. Reducing under-reach and increasing over-reach are the same expansion of the responsive region. Diagnostic: Does enlarging this hit area catch genuine near-misses without capturing taps the user intended for empty space or an adjacent control — and can the user tell where the active boundary actually is?

T3: Sizing for the worst case versus the cost to the common case (bigger targets consume space and slow the median). Sizing and spacing controls for the low-precision tail under the worst expected conditions is what makes an interface inclusive — but larger, more widely spaced targets consume screen real estate, forcing fewer controls per screen, more scrolling, paging, or hidden functionality, and a target sized for essential tremor is larger than a steady-handed expert needs. So designing against the worst case imposes density and efficiency costs on the common case, and the more precisely a layout is tuned to the low-precision tail, the more space it spends and the less it can show at once. Inclusion for the tail and efficiency for the median pull against a fixed screen budget. Diagnostic: Does sizing this control for the worst expected condition leave enough room for the interface's needed density, or is the tail-protective sizing crowding out functionality the median user needs?

T4: Threshold compliance versus genuine usability (hitting 44 points is not hitting the goal). Converting a subjective usability review into a geometric scan against published thresholds (44×44 points, 8-point spacing, WCAG's 24 CSS pixels) is the concept's great practical gift — an objective, auditable check. But the thresholds are blunt minimums, and a layout can satisfy every number while still failing: targets that meet the size floor can be poorly grouped, placed outside the reachable zone, crowded by motion, or sized for a context the guideline never anticipated. The objectivity that makes the scan auditable is exactly what invites compliance theater — passing the measurable check while the actual miss rate under real conditions stays high — because the number certifies geometry, not usability. The measurable proxy and the real goal diverge precisely where context matters most. Diagnostic: Does meeting the sizing threshold actually deliver a low miss rate under this interface's real operating conditions, or is a technically-compliant layout still failing on reach, grouping, or context the threshold does not capture?

T5: Confirmation guards versus friction and habituation (protecting irreversible controls has its own cost). Adding a confirmation step for an irreversible control adjacent to a frequently-tapped one is a standard remedy for accidental activation — it catches the mis-tap before harm. But the guard taxes every legitimate use with an extra interaction, slowing the common path, and habituation erodes it: users who meet the same confirmation repeatedly learn to dismiss it reflexively, clicking through the dialog without reading it, so the guard that was meant to catch the dangerous mis-tap becomes a rubber-stamp that catches nothing. The protection against accidental activation and the friction-plus-habituation that defeats it are the same interposed step. Diagnostic: Is the confirmation guard genuinely interrupting the dangerous mis-tap, or has repetition trained users to dismiss it reflexively while it slows every legitimate use?

T6: Autonomy versus reduction (an HCI failure mode, a Fitts's Law framing, or a resolution-matching instance). Touch-target miss carries visibly touchscreen-and-finger apparatus — the visible-target/hit-area distinction, the 44-point thresholds, the operator-precision tail with gloves and tremor — and within HCI it transfers as mechanism across mobiles, kiosks, voting machines, and infusion pumps. But its quantitative core is Fitts's Law, a sibling HCI entry, so within the domain the portable quantitative form is Fitts, and the failure-mode name is one framing of that content. One level up, the cross-domain concern — an effector's precision mismatched to its target's geometry (circular error probable, tolerance stacks, instrument resolution) — is the parent resolution_matching, each instance carrying its own native math. "Touch-target miss" does not strip cleanly to that parent; applied beyond touch interfaces it is analogy. The tension is triangulated: the concept is a failure-mode framing of Fitts's Law within HCI and a domain instance of resolution matching beyond it, distinctively itself only in its touch-input furniture. Diagnostic: Resolve toward Fitts's Law for the quantitative core within HCI, toward resolution_matching (with the domain's own math) for effector-vs-target mismatch beyond touch interfaces, and toward touch-target miss only when touch/pointer geometry and the operator-precision tail are the actual subject.

Structural–Framed Character¶

Touch-target miss sits at the framed-leaning position on the structural–framed spectrum: a failure-mode-and-fault-attribution concept constituted by the practice of interface design and codified in design standards, resting on a genuine physical substrate that keeps it from the framed pole. The criteria mostly point framed. Its evaluative weight is real: the concept's sharpest move is a reclassification of culpability — from "operator error" to "interface defect" — so it renders a verdict about where fault lies, a normatively loaded judgment, not a neutral description of a mechanism. It is strongly human-practice-bound: a "miss" is defined only relative to a designed target, a programmatically responsive hit area, and an intended operator population under expected conditions — all artifacts of the interface-design practice — so strip away the design of interactive controls and there is no touch-target miss, only a finger landing somewhere; the failure is a property of the designed artifact and its use, not of the world. Its institutional origin is pronounced: the defect classification is anchored to codified guidance — Apple HIG and Material 44-point targets, WCAG 2.5.8, FDA human-factors requirements — design-standards apparatus, not a fact nature marks. On vocab_travels it is domain-pinned: the visible-target/hit-area distinction, the sizing thresholds, and the operator-precision tail carry across touch and pointer devices but not off the touch-input substrate. And on import_vs_recognize it patterns as recognition within HCI and as analogy beyond it.

The structural-looking feature is unusually layered here, and the entry triangulates it: the concept's quantitative core is Fitts's Law (a real, substrate-independent regularity of human motor target acquisition, itself a sibling HCI entry), and its cross-domain concern is the parent resolution_matching — an effector's precision mismatched to the geometry of the target it must hit — which recurs as real co-instances in circular error probable, tolerance stacks, and instrument resolution, each with its own native math. Those are genuine portable structures. But they do not lift touch-target miss off the framed side, because Fitts's Law and resolution-matching are exactly what the entry instantiates from below and specializes from above, not what makes "touch-target miss" itself travel: the quantitative content belongs to Fitts's Law, the cross-domain reach to resolution_matching, while the entry's distinctive cargo — the touchscreen-and-finger apparatus, the visible-target/hit-area lever, the operator-precision tail (gloves, tremor, motion, low light), the interface-defect classification, and the geometry-only fix family — is HCI furniture that stays home. Its character: a normatively charged, interface-design-constituted failure mode that reframes a real Fitts's-Law/resolution-matching substrate as a fault-attribution verdict, structural only in the resolution-matching skeleton it instantiates and the motor law it rests on.

Structural Core vs. Domain Accent¶

This section decides why touch-target miss is a domain-specific abstraction and not a prime, and it carries the case for its domain-specificity in the same move.

What is skeletal (could lift toward a cross-domain prime). Strip the touchscreen and a thin relational structure survives: an effector's precision is mismatched to the geometry of the target it must hit, so acquisition fails at a rate fixed by that mismatch rather than by effort. The portable pieces are abstract — an effector with a precision distribution, a target with a size and separation, and a miss rate read off the gap between them. That skeleton is the parent resolution_matching (match an effector's or instrument's resolution to the precision the task requires), with the concept's quantitative core being the sibling HCI entry Fitts's Law (acquisition time and error logarithmic in the distance-to-width ratio). It is genuinely substrate-spanning — the same mismatch recurs as circular error probable, tolerance stacks, instrument resolution, joystick deadzones, and pipette-vs-heterogeneity footprints, each with its own native math — which is exactly why it is the core touch-target miss instantiates, not what makes the entry the particular thing it is.

What is domain-bound. What makes the concept touch-target miss in particular is human-computer-interaction furniture that does not survive extraction. The visible-target / hit-area distinction (the rendered affordance versus the programmatically responsive region, an independent lever); the touchscreen sizing thresholds (Apple HIG / Material 44-point targets with 8-point spacing, WCAG 2.5.8's 24 CSS pixels, FDA human-factors sizing); the operator-precision tail keyed to gloves, tremor, motor impairment, motion, and low light; and the geometry-only fix family (enlarge the hit area, widen spacing, relocate to the reachable zone, guard irreversible adjacent controls) are the worked apparatus of interface design. The decisive test is twofold: a "miss" is defined only relative to a designed target and a programmatically responsive hit area operated by an intended population, so strip the interface-design practice and there is only a finger landing somewhere; and the concept's sharpest move is a reclassification of culpability — from operator error to interface defect — which is a normative fault-attribution verdict, not a neutral description. The entry is candid that touch-target miss does not strip cleanly to the resolution-matching pattern; the touch-input geometry and operator-precision apparatus are exactly what stays home.

Why this does not clear the prime bar. A prime is a relational structure whose vocabulary travels and whose cross-domain transfer is recognition of the same mechanism, not analogy. Touch-target miss's transfer is bimodal. Within HCI, accessibility, and device design it travels as full mechanism — the geometry-versus-precision scan, the visible-target/hit-area lever, the defect classification, the Fitts's-Law prediction, and the geometry-only remedy carry unchanged across mobiles, kiosks, voting machines, infusion pumps, and control-room panels, because these are one substrate (fingertip/pointer acquisition of designed targets) at many device scales (recognition). Beyond touch interfaces it is analogy: applying "touch-target miss" to a surgical tool too coarse for its structure, a munition's CEP, or a sensor footprint borrows the mismatch shape while dropping the touch-input geometry and operator-precision apparatus. And when the bare structural lesson is wanted cross-domain — match the effector's resolution to the target's geometry — it is already carried, in more general form, by the parent resolution_matching (each domain supplying its own native math), while the portable quantitative form within HCI is Fitts's Law. The cross-domain reach belongs to resolution_matching; the quantitative core belongs to Fitts's Law; "touch-target miss," as named, is the failure-mode framing that keeps the visible-target/hit-area distinction, the touchscreen thresholds, the operator-precision tail, and the interface-defect verdict as accent that stays home.

Relationships to Other Abstractions¶

Current abstraction Touch-Target Miss Domain-specific

Parents (1) — more general patterns this builds on

Touch-Target Miss is a decomposition of Resolution Matching Prime

Touch-Target Miss is resolution mismatch framed as an HCI fault when target geometry is finer than the operating population's effective motor precision.

Hierarchy path (1) — routes to 1 parentless root

Touch-Target Miss → Resolution Matching → Scale

Not to Be Confused With¶

Touch target size (the sibling rule). The design rule prescribing how large and well-spaced interactive elements must be (44 pt / 48 dp / WCAG minimums). Touch-target miss is the failure event and its fault-attribution — a mis-tap reclassified as interface defect. Two sides of one coin: the size rule is the prescription, the miss is the failure the prescription prevents. Tell: is the referent the geometric standard controls should meet (touch target size), or the mis-tap event and its reclassification from user error to design defect (touch-target miss)?
Fitts's Law. The substrate-independent quantitative law — acquisition time logarithmic in the distance-to-width ratio — that models human motor target acquisition anywhere, including pointing in physical space. Touch-target miss is the HCI failure-mode framing that uses Fitts's Law as its quantitative core; the law travels, the failure-mode name does not. Tell: is the referent the motor-acquisition cost model that holds for any pointing (Fitts's Law), or the interface-defect framing of a specific mis-tap (touch-target miss)?
Operator error / user slip. A genuine mistake attributable to the user — an attention lapse, haste, or an error a hittable target still admits. Touch-target miss is precisely the reclassification away from this: when the geometry guarantees a non-trivial miss rate across the population, the fault is the design's, not the user's. But the two are real and distinct — not every miss is geometry-guaranteed. Tell: would a properly sized, well-spaced target have been reliably hittable (residual operator slip), or was the miss rate fixed by the dimensions regardless of skill (touch-target miss)?
Fat-finger error. The colloquial catch-all for any mistyped or mis-tapped input. It names the symptom without diagnosing cause; touch-target miss supplies the mechanism (geometry-versus-precision mismatch) and the fault-attribution rule. A "fat-finger" slip on an adequately sized target is operator error; the same on an undersized one is a touch-target miss. Tell: is it an undiagnosed mis-input label (fat-finger), or specifically a miss the target geometry guaranteed across the operator population (touch-target miss)?
Affordance. Whether a control communicates that it can be acted on — that it is a button, that it is pressable. Touch-target miss concerns whether the available action can be reliably hit (executable), not whether the user knows it is available (affordable). A perfectly affordant button can still be a touch-target miss if too small or crowded. Tell: does the user fail to know the control is tappable (affordance defect), or know but land outside its responsive region (touch-target miss)?
Resolution matching / CEP / tolerance (the parent it instantiates). The substrate-neutral concern — an effector's precision mismatched to the geometry of the target it must hit — carried by resolution_matching and recurring as circular error probable, tolerance stacks, and instrument resolution, each with its own native math. Not a confusable peer but the umbrella; "touch-target miss" does not strip cleanly to it and beyond touch interfaces is analogy. Tell: for effector-vs-target mismatch outside touch UI, the portable content is resolution_matching — treated more fully elsewhere — while the visible-target/hit-area distinction and operator-precision tail are the miss's HCI accent.

Neighborhood in Abstraction Space¶

Touch-Target Miss sits in a moderately populated region (56^th percentile for distinctiveness): it has near-neighbors but no dense thicket of look-alikes.

Family — Unclustered & Miscellaneous (309 abstractions)

Nearest neighbors

Computed from structural-signature embeddings · 2026-07-12