Field + Heart
Thinking requires working memory. Complex thoughts must hold multiple elements simultaneously—premises, implications, counterarguments, connections. When working memory capacity is exceeded, thinking must externalize. Writing becomes extended cognition—paper holds ideas while the mind manipulates them. Interface design serves similar function. Well-structured information architecture externalizes cognitive load. Navigation hierarchies hold organizational structure so users don't maintain it mentally. Search boxes externalize memory retrieval. The interface thinks alongside the user, holding context and structure that would otherwise consume working memory. Poor interfaces force users to maintain complex mental models. Good interfaces externalize that complexity, freeing cognition for actual problems.
Human working memory holds roughly seven items simultaneously. Complex thinking requires juggling more than seven elements. When internal capacity is exceeded, thinking must externalize into environment. Notes capture ideas. Diagrams show relationships. Lists organize tasks.
Interfaces should similarly externalize cognitive complexity. Navigation breadcrumbs show position in hierarchy without requiring users to mentally track it. Progress indicators show completion status without requiring mental counting. Saved states preserve context across sessions without requiring users to remember where they were.
The design question is what to externalize versus what to keep internal. Too much externalization creates visual clutter. Too little externalization exceeds working memory. The balance depends on task complexity and expected user expertise. Novice users need more externalization; experts can internalize more structure.
Conscious thought is largely sequential—one idea after another. But perception and pattern recognition operate in parallel—seeing a face, recognizing danger, reading words. This creates tension between how humans naturally process information and how interfaces present it.
Lists are sequential structures forcing serial processing. Spatial layouts enable parallel scanning. Users can see all options simultaneously in a grid but must read through options sequentially in a list. The structure choice determines whether users can think in parallel or must think sequentially.
Complex decisions benefit from parallel presentation enabling comparison. Simple selections work fine sequentially. The designer must match presentation structure to thinking style the task requires. Forcing parallel thinking into sequential structures slows decision-making. Forcing sequential thinking into parallel structures creates confusion.
Interface complexity creates cognitive load—mental effort required to use the system. This load can be intrinsic (necessary for the task), extraneous (unnecessary overhead from poor design), or germane (productive effort building understanding).
Good design minimizes extraneous load and optimizes germane load. Extraneous load includes remembering what icons mean, interpreting unclear labels, navigating illogical hierarchies. These impose mental effort without advancing task goals. Germane load includes understanding domain concepts, making informed decisions, learning system capabilities. This effort builds user competence.
The reduction strategy differs. Extraneous load is eliminated through better design—clearer labels, sensible organization, consistent patterns. Germane load is distributed through progressive disclosure—introduce complexity gradually as users build mental models. Attempting to eliminate germane load oversimplifies and prevents users from developing expertise.
Users construct mental models of how systems work. These models predict system behavior and guide action. The system's actual structure (system image) should align with intended mental model. Misalignment creates confusion—users expect behavior system doesn't provide, or system offers capabilities users don't recognize.
Consistent interaction patterns enable accurate mental models. If buttons always behave similarly, users develop reliable expectations. If buttons sometimes trigger immediate action and sometimes open dialogs, the inconsistency prevents model formation.
The mental model need not match implementation details. Users don't need to understand technical architecture—they need to predict behavior accurately. A simplified mental model that reliably predicts behavior is better than technically accurate model that's too complex to apply. The "desktop" metaphor is technically inaccurate but provides workable mental model for file management.
Attention is limited resource. Users can focus on one thing at a time—everything else receives only peripheral monitoring. Interface design directs attention through visual hierarchy, motion, color, contrast. The design controls what receives focused attention versus what remains peripheral.
Critical information should command attention. Errors, alerts, required actions—these should be visually prominent. Peripheral information should be visible but not distracting. Status indicators, metadata, optional features—these should be available without demanding attention.
The failure mode is equal emphasis. When everything tries to command attention, nothing succeeds. The visually dense interface with equal contrast, weight, and size throughout creates perceptual noise. Users cannot identify what matters. Effective hierarchy requires subordinating less important elements to emphasize critical ones.
Repeated decisions deplete cognitive resources. Each choice requires mental effort. Too many decisions exhaust users. This explains why overwhelming choice arrays reduce satisfaction—the cognitive cost of deciding outweighs the benefit of having options.
Interfaces should minimize trivial decisions. Default values reduce decision count. Intelligent automation eliminates decisions. Clear recommendations guide when decisions are necessary. The goal is preserving decision capacity for meaningful choices while automating or eliminating trivial ones.
But some users want control over details others find trivial. The expert wants granular settings the novice finds overwhelming. This suggests tiered complexity—simple defaults with expert options hidden behind progressive disclosure. Novices make few decisions; experts access detailed controls. The interface adapts to user sophistication.
Recognition (selecting from visible options) is easier than recall (retrieving from memory). Menus showing available commands are easier than remembering command syntax. Icon selection is easier than typing filenames from memory. Interfaces should favor recognition over recall.
But recognition requires visible prompts. Command-line interfaces favor recall but enable powerful expression through composition. The trade-off is ease versus capability. Recognition interfaces are learnable but verbose. Recall interfaces are efficient but demanding.
The solution is layered interaction. Beginners use menus (recognition). Experts learn keyboard shortcuts (recall). Both approaches remain available. The interface supports progressive transition from recognition-based exploration to recall-based efficiency as expertise develops.
Information is easier to process when organized into chunks. Phone numbers group digits. Outlines nest topics. File systems use directories. The chunking reflects natural cognitive organization—grouping related items reduces mental overhead.
Flat structures require holding all items in memory simultaneously. Hierarchical structures allow focusing on one level at a time. Users navigate into relevant category, examine contents, then back out—keeping only current level in active consideration. The hierarchy externalizes organization that would otherwise consume working memory.
But excessive hierarchy creates navigation burden. Too many levels mean users lose track of position. Too few levels mean overwhelming choice at each level. Optimal hierarchy balances depth (number of levels) against breadth (items per level). The balance depends on total item count and natural categorical structure.
Interface feedback completes thought loops. User intends action, executes it, observes result, confirms intention was achieved. Without observable result, the thought remains incomplete. Did the click register? Did the save succeed? The uncertainty creates anxiety and repetition.
Immediate feedback closes the loop. Button state changes confirm click. Success messages confirm save. Progress indicators confirm ongoing processing. The feedback doesn't just inform—it completes the cognitive action sequence. The thought can be released from working memory because confirmation indicates completion.
Delayed feedback forces holding the action in memory while waiting for confirmation. The user cannot mentally move on because the previous action isn't confirmed complete. This occupies working memory that could be directed toward next action. Slow feedback doesn't just waste time—it consumes cognitive capacity.
Automation offloads thinking to systems. Spell-check automates error detection. Auto-fill automates data entry. Recommendations automate selection. This offloading reduces cognitive demand but also reduces learning and agency.
The question is what should be automated versus what should require deliberate thought. Safety-critical decisions should require conscious approval even if systems can automate them. Repetitive mechanical tasks should be automated to free cognition for meaningful work. The division depends on error consequences and learning value.
Over-automation creates learned helplessness—users lose capability to perform tasks manually. Under-automation wastes human cognition on mechanical tasks. The balance requires understanding which cognitive activities build valuable skill versus which are pure overhead. Automate overhead; preserve skill-building activities.