Mode Error¶

The interaction failure in which the same user action is interpreted differently by a system depending on a hidden mode the user does not perceive — the user acts correctly for the mode they believe is active, and the system, in the actually active mode, does something else.

Core Idea¶

A mode error is the HCI and human-factors failure in which the same physical or motor action by a user is interpreted differently by a system depending on a hidden mode the user does not currently perceive — the user performs the action that would be correct in the mode they believe the system is in, and the system, in the actually active mode, performs a different action. The structural commitment has three parts: the action space is mode-overloaded (the same gesture carries more than one possible interpretation, selected by mode); the mode indicator is weak, absent, or peripheral to the user's attention under operating conditions; and the mode transition is hidden, automatic, or unobserved, so the user's expected mode and the system's actual mode diverge without the user registering the divergence. The canonical instances span text editors (vi keystrokes that are text in insert mode and commands in command mode), glass-cockpit autopilot mode confusion (Sarter and Woods's research on flight-deck incidents; autothrottle FLCH vs V/S vs VNAV mode confusion), anaesthesia-machine ventilation modes (SIMV, PRVC, AC — same controls, different semantics by mode), medical infusion pump modes (bolus vs continuous, basal vs prime), automotive electronic shifters (the Jeep electronic-shifter recall is a mode-error case), and touch-surface modal interaction. Norman and Sellen's HCI work, and Cooper's About Face, established mode error as a structural design failure, not a user attention failure: the user did exactly what they intended, and the interpretive mismatch is a property of the design, not a deficit of the operator. The mature defence set — modeless design where possible, strong persistent mode indicators using colour and shape, spring-loaded modes that revert on release, mode-transition annunciation, mode-error-tolerant action mappings — is precisely aimed at preventing the gap between user-believed mode and system-actual mode from opening or from being consequential when it does.

Structural Signature¶

Sig role-phrases:

the control surface — an interface offering a finite set of physical or motor gestures
the mode-overloaded action space — the same gesture carrying more than one possible interpretation, selected by the active mode
the weak mode indicator — a mode signal absent, faint, or peripheral to the user's attention under operating conditions
the hidden transition — the system entering its current mode automatically, on a timer, or via an action the user did not register as mode-changing
the believed-vs-actual divergence — the user's model of the active mode parting from the system's actual mode without the user registering it
the correct-in-believed-mode action — the user executing exactly the gesture that would be right in the mode they believe is active, so the fault is the design's by stipulation, not the operator's
the taxonomy boundary — separating mode error (right goal, clean execution, silently shifted interpretation) from a slip (motor stumble) and a mistake (flawed goal cleanly executed), each routed to a different lever
the stakes-scaled cost — consequence ranging from a stray character to a held-thrust or wrong ventilator breath, concentrated under high workload, distraction, and out-of-view displays
the one-lever-per-condition defence — modeless design (remove overloading), persistent colour-and-shape indication (strengthen the signal), spring-loaded modes and mode-tolerant mappings (make a wrong-mode action harmless or self-reverting), transition annunciation

What It Is Not¶

Not "user error" in the naive sense. The user executed exactly the action they intended, correctly, and it was right in the mode they believed was active. The mismatch is a property of an interpretive mapping that shifted without announcing itself — the fault is the design's by stipulation, not a deficit of operator attention or skill.
Not a slip. A slip is the right goal undone by a motor stumble — the hand fumbled the gesture. A mode error has clean motor execution; what defeats it is the system's silently shifted interpretation of a correctly-performed action. Correct intent plus correct execution plus a wrong result is the mode-error signature, not the slip's.
Not a mistake. A mistake is a flawed goal executed cleanly — the wrong plan, carried out correctly. A mode error has the right goal; the divergence is between the user's believed mode and the system's actual mode, not in the user's intention. Misfiling it as a mistake aims the fix at mental models when the fix is mode visibility.
Not fixable by training. Training cannot close a gap the design keeps reopening; under workload, distraction, and out-of-view displays the next operator loses mode track the same way. The load-bearing remedies are structural — modeless design, persistent indication, spring-loaded modes — not "train the operator harder."
Not microcopy ambiguity. Microcopy ambiguity is a label that admits multiple readings of a single fixed action; a mode error is a single gesture whose meaning is mode-relative, with the active mode unperceived. One is bit-starved surface text, the other is an unannounced interpretive state — sibling interaction failures with different cures.
Not contextual_mode_switching as such. The prime names context-relative behaviour neutrally; mode error adds the failure accents — the user does not perceive the active mode, the transition was hidden, and the action was correct-in-the-believed-mode, making it the design's fault. The substrate-neutral state-relative-interpretation pattern belongs to that parent (with frame_of_reference and state_machine); the unawareness and the defence set are the HCI-specific cargo.

Scope of Application¶

Mode error lives across HCI, aviation human factors, medical-device design, and control-room engineering — wherever a control surface interprets a gesture mode-relative and the active mode can go unperceived; its reach is within that domain, the habitats being mode-dependent control interfaces. The cross-substrate analogues (a status-dependent legal act, a culture-dependent gesture, a protocol-state-dependent packet) belong to the parent bundle contextual_mode_switching / frame_of_reference / state_machine, not to "mode error" as named.

Text editors and modal interfaces — vi/vim insert-versus-command confusion, Emacs prefix-key state, modal-dialog focus traps, and touchscreen edit/view/select modes.
Aviation autopilot and autothrottle modes — Sarter and Woods's glass-cockpit incidents and FLCH/V·S/VNAV confusion, where a held thrust the crew expected to advance can be catastrophic.
Anaesthesia and ICU ventilator modes — SIMV/PRVC/AC modes where the same control changes meaning, documented in mode-confusion adverse events.
Medical infusion pumps — bolus-versus-continuous and basal-versus-prime modes, the same buttons doing different things by mode.
CNC machinery and industrial controls — setup-versus-run-versus-maintenance modes where a wrong-mode action causes workpiece damage, collisions, or injury.
Automotive controls — D/R/P electronic shifters (the Jeep recall), cruise-control modes, and drive-mode selectors that change pedal mapping.
Game controllers and assistive technology — device states (voice-control state, switch-scanning modes) where the same input is read differently by mode.

Clarity¶

Naming mode error rescues a class of incidents from the catch-all verdict of "user error." Lacking the concept, an investigator sees an operator who pressed the right control and got the wrong result, and books it as inattention or insufficient training — closing the case on the human and leaving the design untouched. The concept relocates the fault: the user executed exactly the action they intended, correctly, and the mismatch is a property of an interpretive mapping that changed without announcing itself. That re-attribution is consequential, because it redirects the remedy from "train the operator harder" — which cannot close a gap the design keeps reopening — to modeless design, persistent mode indication, and spring-loaded modes, reframing those from ergonomic niceties into load-bearing safety interventions.

Its second service is to slot precisely into the human-factors error taxonomy, distinguishing three things that "the operator messed up" fuses. A slip is the right goal undone by a motor stumble; a mistake is a flawed goal executed cleanly; a mode error is the right goal and clean execution defeated by a system whose interpretation of the action silently shifted. Holding these apart tells the analyst which lever applies — better feedback for slips, better mental models for mistakes, mode visibility and modelessness for mode errors — so the sharper question becomes not "was the user careless?" but "did the user's believed mode and the system's actual mode diverge, and was the indicator strong enough to catch it?"

Manages Complexity¶

A wide spread of incidents — a corrupted document from stray vi keystrokes, an autothrottle that held thrust the crew expected it to advance, a ventilator delivering the wrong breath, a shifter left in the wrong gear — arrives, without the concept, under one undifferentiated verdict ("user error") that names no cause and licenses one reflexive remedy (more training), which cannot close a gap the design keeps reopening. Mode error compresses that sprawl by reducing each such failure to three structural conditions that either hold or do not: the action space is mode-overloaded, the mode indicator is weak or peripheral, and the mode transition is hidden or unobserved. Where all three hold, the analyst need not reconstruct the operator's attention or skill; the diagnosis collapses to a single readout — did the user's believed mode and the system's actual mode diverge, and was the indicator strong enough to catch it? — and the action is, by stipulation, correct in the believed mode, so the fault is relocated from the operator to the interpretive mapping. That same set of conditions hands the designer the matching levers as a fixed menu: remove the overloading (modeless design), strengthen the indicator (persistent colour and shape), or make a wrong-mode action harmless or self-reverting (spring-loaded modes, mode-tolerant mappings) — each aimed at one of the three conditions. The compression is sharpened by the surrounding error taxonomy, which sorts what "the operator messed up" fuses into three cases routed to three different levers: a slip wants better feedback, a mistake wants a better mental model, and a mode error wants mode visibility and modelessness. The analyst thus tracks three conditions and a believed-versus-actual mode comparison and reads off both the attribution and the remedy, instead of booking an open-ended judgment of operator competence that points at no fix.

Abstract Reasoning¶

Mode error licenses reasoning moves built on its three structural conditions — a mode-overloaded action space, a weak or peripheral indicator, a hidden or unobserved transition — and on one stipulation that flips the usual attribution: the action was correct in the mode the user believed was active.

Diagnostic, relocating the fault from operator to mapping. The signature inference, faced with an operator who pressed the right control and got the wrong result, reasons that the user executed exactly the action they intended and that the mismatch therefore lives in an interpretive mapping that shifted without announcing itself. The analyst tests the three conditions: was the same gesture overloaded across modes, was the indicator too weak or peripheral to read under operating conditions, did the mode transition happen unobserved? Where all three hold, the diagnosis collapses to a single comparison — did the user's believed mode and the system's actual mode diverge, and was the indicator strong enough to catch it? — and the verdict is mode error, not inattention. The error taxonomy sharpens the inference by exclusion: a slip is the right goal undone by a motor stumble, a mistake is a flawed goal executed cleanly, and a mode error is the right goal and clean execution defeated by a silently shifted interpretation — so observing correct intent plus correct motor execution plus a wrong result is the mode-error signature, distinguishable from the other two.

Interventionist, each lever aimed at one condition. Because the fault is structural, the licensed remedy is design change, not "train the operator harder" — which is predicted to fail, since training cannot close a gap the design keeps reopening. The interventions map one-to-one onto the three conditions, and each carries a prediction: remove the overloading (modeless design) so the gesture has a single meaning and the divergence cannot arise; strengthen the indicator (persistent colour and shape) so the believed mode is forced to match the actual one before the gesture; or make a wrong-mode action harmless or self-reverting (spring-loaded modes that revert on release, mode-tolerant mappings) so that even when the gap opens it is not consequential. The analyst reasons from which of the three conditions is most tractable in a given interface to which lever to pull, and predicts the effect — a spring-loaded mode, for instance, is predicted to eliminate the consequence of the error without eliminating the mode.

Boundary-drawing, on attribution and on which lever applies. Two boundaries are drawn. The attribution boundary separates design fault from operator deficit: the action being correct-in-the-believed-mode places the fault on the system by stipulation, so the case is booked against the design rather than closed on the human. The taxonomy boundary separates the three error types and routes each to its own lever — better feedback for slips, better mental models for mistakes, mode visibility and modelessness for mode errors — so misclassifying a mode error as a slip or mistake would aim the wrong remedy. The reasoning forces the prior question "did believed and actual mode diverge?" before any fix is chosen.

Predictive, on when and where the gap opens. The three conditions predict the operating circumstances under which mode errors surface: high workload, distraction, peripheral or out-of-view displays, and automatic or time-triggered transitions are exactly the conditions that keep the indicator unread and the transition unregistered, so the analyst predicts mode errors concentrate there rather than in calm, attentive use. And the cost is predicted to scale with what a wrong-mode action controls — trivial where it injects a stray character into a document, severe where it holds thrust an aircrew expected to advance or delivers the wrong ventilator breath — ordering interfaces by where a believed-versus-actual divergence does the most damage.

Knowledge Transfer¶

Within HCI, aviation human factors, medical-device design, and control-room engineering the concept transfers as mechanism, because its load-bearing apparatus — the three structural conditions (mode-overloaded action space, weak or peripheral indicator, hidden or unobserved transition), the believed-versus-actual mode comparison, the attribution flip (the action was correct in the believed mode, so the fault is the design's), the slip/mistake/mode-error taxonomy, and the one-lever-per-condition defence set — presupposes only a control surface whose interpretation of a gesture is mode-relative. That holds across the domain's surfaces without translation: modal text editors (vi insert versus command mode), glass-cockpit autopilot and autothrottle modes (Sarter and Woods; FLCH/V·S/VNAV confusion), anaesthesia and ICU ventilator modes (SIMV/PRVC/AC), infusion-pump modes (bolus/continuous, basal/prime), CNC setup-versus-run modes, automotive electronic shifters and drive-mode selectors (the Jeep recall), and assistive-technology device states. The same remedies (modeless design, persistent colour-and-shape indication, spring-loaded modes that revert on release, mode-tolerant mappings, transition annunciation) carry across all of them, and the prediction that errors concentrate under high workload, distraction, and out-of-view displays applies identically. The vocabulary does not strain across these because they are one substrate: mode-dependent control interfaces.

Beyond HCI the honest account is a shared abstract mechanism — case (B), and a well-attested one. Strip the interface idiom and a substrate-neutral structure remains: the same action means something different under a hidden state the actor does not perceive, the actor's model of the state diverges from the true state, and the action is correct relative to the believed state and wrong relative to the actual one. That structure genuinely recurs across distinct substrates as co-instances, not resemblances — an act legal under one license or jurisdiction status and illegal under another, performed by someone whose status changed without notice; a gesture (thumbs-up) that means approval in one culture and an obscenity in another; a packet whose meaning depends on a hidden protocol/handshake state; role-state-dependent speech ("you may sit down" from a host versus a judge); an auction gesture that triggers buy in one phase and pass in another; a signal that elicits different gene expression depending on cell-cycle or differentiation state. In each, the general pattern — state-relative interpretation of an action with a divergence between believed and actual state — is the thing that travels and carries a real, transferable lesson: make the active state legible, reduce overloading, or make a wrong-state action harmless. What does not travel is the HCI cargo: mode indicators, spring-loaded modes, modelessness, and the interface-design surface where the defence is deployed are human-factors furniture that does not survive extraction. And here the residue is carried by a small cluster already in the catalog: contextual_mode_switching (context-relative behaviour, the nearest parent), frame_of_reference (the actor's frame diverging from the system's), state/state_machine reasoning, signaling/signal_decay_and_fadeout (the mode indicator as a weak signal), and error_proofing_poka_yoke (the defence family). So when the cross-domain lesson is wanted, the honest move is to carry that bundle of parents (of which mode error is the HCI instantiation, sibling to microcopy_ambiguity and motion_triggered_harm), not the term "mode error," whose machinery is substrate-bound (see Structural Core vs. Domain Accent).

Examples¶

Canonical¶

The vi/vim text editor is the textbook instance. vi has two principal modes: insert mode, where keystrokes become text, and command (normal) mode, where the same keystrokes are editing commands. The letters "dd," typed in insert mode, insert the characters "dd"; typed in command mode, they delete the current line. A user who believes they are in insert mode, but who is actually in command mode — perhaps because an earlier Escape key or a paused workflow switched it without their noticing — types what they intend as text and instead issues a stream of destructive commands, silently mangling the document. The keystrokes were exactly what the user meant for the mode they believed active; the editor, in its actual mode, did something entirely different.

Mapped back: The keyboard is the control surface; "dd" carrying two meanings is the mode-overloaded action space, and vi's famously subtle mode display is the weak mode indicator. An unnoticed Escape is the hidden transition producing the believed-vs-actual divergence, and the user typing correctly-for-insert-mode is the correct-in-believed-mode action that places the fault on the design.

Applied / In Practice¶

Aviation human factors treats autopilot mode confusion as a safety-critical form of mode error. In the April 1994 crash of China Airlines Flight 140 at Nagoya, the crew was manually flying an approach when the go-around (TOGA) mode was inadvertently engaged. The autothrottle and autopilot, now in a mode commanding a climb, worked against the pilots' inputs to descend and land; the mismatch drove the aircraft badly out of trim, and it stalled and crashed, killing 264 of the 271 aboard. Investigators identified the crew's misunderstanding of the active automation mode — and the automation's insufficient annunciation of the conflict — as central, a case Sarter and Woods's "automation surprise" research had been warning about.

Mapped back: The flight-deck automation is the control surface; the inadvertent TOGA engagement is the hidden transition opening a believed-vs-actual divergence between the crew's "we are landing" mode and the system's "going around" mode. The pilots' descent inputs were correct-in-believed-mode, and the fatal outcome is the stakes-scaled cost — the same structural error that in vi costs a few characters here costs the aircraft.

Structural Tensions¶

T1: Design-fault attribution versus operator accountability (relocating blame that is also a real signal). The concept's re-attribution — the user did exactly what they intended, correct in the believed mode, so the fault is the design's by stipulation — is its liberating move: it redirects the remedy from "train harder" to modeless design and persistent indication. But the stipulation is strong, and applied indiscriminately it can absolve genuine attention failures: not every wrong-result-after-a-correct-gesture is a mode error, and booking every one against the design forfeits the diagnostic work of confirming the three conditions actually held. The attribution flip corrects naive "user error" but can overcorrect into never examining the operator at all. Diagnostic: Did the three structural conditions genuinely hold — overloaded action, weak indicator, unobserved transition — or is "mode error" being used to excuse an ordinary lapse?

T2: Modes as expressive economy versus modes as hazard (the overloading it indicts is also useful). The cleanest fix is modelessness — give each gesture one meaning so the divergence cannot arise. But modes exist because they buy expressive economy: a finite set of gestures does far more work when their meaning is mode-relative, which is exactly why vi, cockpits, and infusion pumps are modal in the first place. Eliminating overloading can mean a larger, more cluttered, or slower control surface, so the remedy trades one cost (mode-error risk) for another (lost economy of the gesture set). Modelessness is not free; it is a design position with its own price. Diagnostic: Does removing the overloading buy enough safety to justify the expressive economy or control-surface simplicity it costs?

T3: Spring-loaded modes versus eliminating the mode (removing the consequence is not removing the divergence). Among the defence set, spring-loaded modes and mode-tolerant mappings are distinctive: they leave the mode in place and make a wrong-mode action harmless or self-reverting, so the believed-versus-actual gap can still open but does not bite. This is often the only feasible move where the mode is load-bearing — but it accepts that the divergence persists, betting that consequences can be neutralized everywhere they matter. Where a wrong-mode action has an irreversible effect the instant it fires, "harmless on release" does not save it. Diagnostic: Can every consequential wrong-mode action be made self-reverting, or does some action commit irreversibly before the spring can restore the safe state?

T4: Stakes-scaled cost versus uniform mechanism (the same structure, trivial here and catastrophic there). The three conditions are identical whether the surface is a text editor or a flight deck, which is what lets one diagnosis span vi and China Airlines 140 — but the cost is not identical, scaling with what a wrong-mode action controls. This cuts two ways: it lets the analyst rank interfaces by where a divergence does the most damage and concentrate defence there, but it also means a mechanism that looks benign in low-stakes testing (a stray character) is the same mechanism that holds thrust or delivers a wrong ventilator breath. Familiarity with the trivial case can under-prepare the designer for the severe one. Diagnostic: Does the wrong-mode action here inject a recoverable nuisance, or command something whose consequence is safety-critical and irreversible?

T5: Autonomy versus reduction (its own HCI failure or the interface instance of its parent bundle). "Mode error" is the HCI instantiation, with mode indicators, spring-loaded modes, modelessness, and the interface-design surface as its cargo. Strip that and a substrate-neutral structure remains — the same action means something different under a hidden state the actor does not perceive, the believed state diverging from the true one — carried by a small cluster already in the catalog: contextual_mode_switching (the nearest parent), frame_of_reference, state/state_machine, signaling/signal_decay_and_fadeout (the weak indicator), and error_proofing_poka_yoke (the defence family). That bundle is what recurs in a status-dependent legal act, a culture-dependent gesture, or a protocol-state-dependent packet. Diagnostic: Resolve toward the contextual_mode_switching bundle when carrying the lesson to non-interface substrates; toward "mode error" when diagnosing a mode-relative gesture on a control surface.

Structural–Framed Character¶

Mode error is framed-leaning on the structural–framed spectrum — a named interaction failure whose portable core is a genuinely structural state-relative-interpretation pattern, but which is itself constituted by a human-machine-interface practice and carries an attribution-flipping verdict, so it sits toward the framed end. The criteria: evaluative weight points framed — "error" convicts, and the concept's signature move is a normative re-attribution (the fault is the design's, not the operator's), so it is deployed to assign blame and mandate a fix, not merely to describe a neutral state-dependence (which is exactly what its parent contextual_mode_switching does). Human-practice-bound points framed: a mode error exists only where there is a control surface, a user with a mental model, and a designed interface between them; it dissolves without that interaction practice — there is no mode error in observer-free nature, only, at most, the neutral state-relative-interpretation the parent names. Institutional origin is framed: the diagnostic-and-defence apparatus — the slip/mistake/mode-error taxonomy, mode indicators, spring-loaded modes, modelessness, poka-yoke mappings — is human-factors and interaction-design furniture from a specific engineering tradition (Norman, Sellen, Cooper, Sarter & Woods). Vocab-travels is low: mode indicator, mode-overloaded action space, transition annunciation are interface idiom. Import-vs-recognize is bimodal in the entry's telling — within HCI, aviation, medical-device, and control-room design it transfers as recognition of the same mechanism across every mode-dependent surface, while the cross-substrate cases (a status-dependent legal act, a culture-dependent gesture, a protocol-state packet) are genuine co-instances of the parent pattern, and calling them "mode error" is import-by-analogy of the HCI-specific name.

The portable structural skeleton is a single one: state-relative interpretation of an action with a divergence between believed and actual state — the same action means something different under a hidden state the actor does not perceive, so it is correct relative to the believed state and wrong relative to the actual one. That skeleton genuinely recurs across substrates (law, culture, network protocols, gene regulation), but it is exactly what mode error instantiates from its parent bundle — contextual_mode_switching (the nearest parent, which names the state-relative behaviour neutrally), frame_of_reference (the actor's frame diverging from the system's), state / state_machine, signaling / signal_decay_and_fadeout (the weak indicator), and error_proofing_poka_yoke (the defence family) — not what makes "mode error" itself travel: the cross-domain reach belongs to that bundle, while the HCI cargo (mode indicators, spring-loaded modes, modelessness, the interface-design surface) stays home. Its character: a normatively-charged, interface-practice-constituted HCI failure mode, structural only in the state-relative-interpretation skeleton it borrows from contextual_mode_switching and its cluster, and framed here as a design-fault verdict.

Structural Core vs. Domain Accent¶

This section settles why mode error is a domain-specific abstraction and not a prime, and carries the case for its domain-specificity along with it.

What is skeletal (could lift toward a cross-domain prime). Strip the interface idiom and a thin relational structure survives: the same action means something different under a hidden state the actor does not perceive, so the actor's model of the state diverges from the true state, and the action is correct relative to the believed state and wrong relative to the actual one. The portable pieces are abstract — an action whose interpretation is state-relative, a believed-versus-actual state divergence, and unawareness of the active state. That skeleton is genuinely substrate-portable, which is why it recurs as an act legal under one license status and illegal under another performed by someone whose status changed unnoticed, a thumbs-up that means approval in one culture and an obscenity in another, a packet whose meaning depends on a hidden protocol handshake state, or a signal read differently depending on cell-cycle state. It is exactly what the catalog already carries as contextual_mode_switching (the nearest parent, naming state-relative behaviour neutrally), with frame_of_reference (the actor's frame diverging from the system's), state / state_machine reasoning, signaling / signal_decay_and_fadeout (the mode indicator as a weak signal), and error_proofing_poka_yoke (the defence family). But this is the core mode error shares with those co-instances, not what makes it distinctive.

What is domain-bound. Almost everything that makes the concept mode error in particular is HCI and human-factors furniture, and none of it survives extraction. The state is a mode of a control surface; the action is a physical or motor gesture; the divergence is diagnosed by three named conditions (mode-overloaded action space, weak or peripheral mode indicator, hidden or unobserved transition); the attribution flip is the human-factors stipulation that the operator did exactly what they intended so the fault is the design's; the error taxonomy places it against slip and mistake; and the defence set is interface engineering — modeless design, persistent colour-and-shape indication, spring-loaded modes that revert on release, mode-tolerant mappings, transition annunciation. The worked cases are equally home-bound: vi insert-versus-command, glass-cockpit FLCH/V·S/VNAV confusion, SIMV/PRVC/AC ventilator modes, infusion-pump bolus/continuous, the Jeep electronic-shifter recall. The decisive test: remove the designed control interface and the operator's mental model of it, and there is no mode indicator to strengthen, no spring-loaded revert, no slip/mistake contrast — what remains is the neutral state-relative-interpretation the parent names, a sibling case, not "mode error." Its very name carries the failure accent — the unawareness, the hidden transition, the design-fault verdict — that the neutral parent lacks.

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. Mode error's transfer is bimodal. Within HCI, aviation human factors, medical-device design, and control-room engineering the full apparatus travels intact — the three structural conditions, the believed-versus-actual comparison, the attribution flip, the slip/mistake/mode-error taxonomy, and the one-lever-per-condition defence set presuppose only a control surface whose gesture-interpretation is mode-relative, so they carry without translation from a text editor to a flight deck to a ventilator, and the same structural error that costs a stray character in vi costs an aircraft in China Airlines 140. Beyond it, transfer is only by analogy: calling a status-dependent legal act or a protocol-state-dependent packet a "mode error" borrows the HCI name for a genuine co-instance of the parent pattern, because the mode indicators, spring-loaded modes, and interface-design surface do not survive the crossing. And when the bare structural lesson is needed cross-domain — make the active state legible, reduce overloading, make a wrong-state action harmless — it is already carried, in more general form, by the parent bundle the entry instantiates: contextual_mode_switching, frame_of_reference, state_machine, signaling, and error_proofing_poka_yoke. The cross-domain reach belongs to that bundle; "mode error," as named, is its HCI instantiation, carrying human-factors baggage that should stay home.

Relationships to Other Abstractions¶

Current abstraction Mode Error Domain-specific

Parents (2) — more general patterns this builds on

Mode Error presupposes Contextual Mode Switching Prime

A mode error presupposes a system that switches among discrete context-selected mappings before the user's believed mode can diverge from the active one.
Mode Error is part of Mental Model Prime

Mode error contains the operator's internal model of the active mode whose prediction is correct for the believed state but mismatched to the system's actual state.

Hierarchy paths (3) — routes to 3 parentless roots

Mode Error → Contextual Mode Switching → Adaptation

Show alternative paths (2)

Not to Be Confused With¶

Slip. In the human-factors error taxonomy, the right goal undone by a motor stumble — the intended action fumbled in execution (a mistyped key, a wrong button hit). Mode error has clean motor execution; the gesture is performed exactly as intended and is right for the believed mode, and only the system's silently shifted interpretation defeats it. Slip and mode error route to different levers (better feedback versus mode visibility). Tell: did the hand execute the wrong movement (slip), or execute the right movement that the system read under an unperceived mode (mode error)?
Mistake. A flawed goal executed cleanly — the wrong plan carried out correctly, rooted in a bad mental model or misjudged situation. Mode error keeps the right goal; the divergence is between the user's believed mode and the system's actual mode, not in the intention or the plan. Misfiling a mode error as a mistake aims the fix at mental models when the fix is mode visibility and modelessness. Tell: was the plan itself wrong for the goal (mistake), or was the plan right and only the mode-relative interpretation wrong (mode error)?
Lapse. A memory failure in which an intended step is forgotten or omitted — the operator loses their place and skips an action. Mode error involves no forgotten step: the action is performed, on time and as intended; what fails is its interpretation under a hidden state. Tell: was a planned action dropped from working memory (lapse), or fully carried out but interpreted under the wrong mode (mode error)?
Capture error. A slip-type failure in which a frequently practised action sequence hijacks a less-frequent intended one at a shared branch point (starting a familiar routine instead of the new one). Its cause is habit strength, not a hidden interpretive state; the wrong action is generated by the operator, whereas in mode error the correct action is reinterpreted by the system. Tell: did a well-worn habit substitute itself for the intended action (capture error), or did the intended action get read differently because of an unperceived mode (mode error)?
Automation surprise / mode confusion. The broader Sarter-and-Woods category in which an automated system behaves in a way the operator did not expect and cannot readily explain ("what is it doing now?"). Mode error is the specific action-interpretation failure — a gesture read under the wrong mode — that is one common source of automation surprise, but automation surprise also covers unexpected autonomous transitions and behaviours with no user gesture at issue. Mode error is the narrower, action-triggered case. Tell: is the operator surprised by what the system did on its own (automation surprise), or specifically by their own correct action being interpreted under an unperceived mode (mode error)?
contextual_mode_switching and its bundle (parent). The substrate-neutral parent — state-relative interpretation of an action, named neutrally — together with frame_of_reference, state_machine, signaling, and error_proofing_poka_yoke. Mode error adds the failure accents the neutral parent lacks: the active state is unperceived, the transition was hidden, and the action was correct-in-the-believed-mode, making it the design's fault. The status-dependent legal act and the culture-dependent gesture are co-instances of the parent, not of mode error. Tell: the parent bundle carries the neutral state-relative structure cross-domain; mode error is the HCI failure instantiation with mode indicators and spring-loaded modes, treated more fully in a later section.

Neighborhood in Abstraction Space¶

Mode Error sits in a sparse region of the domain-specific corpus (76^th percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely.

Family — Interface Legibility & Navigability (12 abstractions)

Nearest neighbors

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