Removing external representations increases internal load

What it is

Deleting a note, collapsing a list, hiding a column, disallowing screenshots, or clearing history does not make the cognitive demand disappear; it shifts comparison, sorting, time calculation, and accountability tracking into the user's head or an improvised external tool. As internal load rises, error, fatigue, and help-seeking rise with it. This card is the inference within distributed cognition theory that design decisions most easily overlook, and the one most worth stating on its own: it runs the previous two cards' logic in reverse — if cognition really is distributed between a person and a representation, and the representation carries real computation, then taking the representation away does not make that computation vanish; it is simply forced to move back from the representation's side to the person's side.

Why it happens

Behind this inference is a relationship resembling conservation: the total volume of information and relationships a task needs to process is, given a fixed task goal, roughly constant, and all a cognitive system can decide is who carries out that processing — leaving it in an external representation, done by the interface's structure on the user's behalf, or moving it back into the user's working memory, maintained by the user's own head. Working memory's capacity and retention span are both severely limited, so once a piece of information that was externalized gets removed, the user is either forced to hold price, ID, filter conditions, current step, and why they made an earlier choice all in mind at once, or they fall back on making their own makeshift external representation with a screenshot, a note, or an external spreadsheet. This is why an interface that "looks simpler" can sometimes carry a higher total cognitive cost: the interface itself genuinely got simpler, but if that simplicity was bought by removing information that should have stayed external, the cognitive cost the user actually pays has not decreased — it has only shifted from "visible complexity on screen" to "invisible weight the user carries alone," and the latter is generally more prone to mid-task error or omission than the former.

Where it stops holding

This does not mean every representation should stay permanently on screen unconditionally — laying out every historical record and every filter condition permanently across the screen creates its own new perceptual burden, burying the one piece of information a user actually needs among a pile of equally prominent ones. Here, collapsing and summarizing are reasonable design moves, provided the relationship that gets collapsed can still be retrieved at the decision point where it is actually needed, rather than disappearing entirely. Security and privacy can also be legitimate grounds for restriction — some information genuinely should not be exportable or screenshottable — but that restriction should not crudely manifest as "show nothing at all"; it should instead offer a permission-controlled summary view, so whoever needs to see the key information still can, while the details they should not see stay hidden. The test for whether a given collapse or removal is reasonable comes down to asking: "will the user actually need this piece again later, and if so, how will they get it back?"

Applying it

• Audit the external sticky notes, phone screenshots, and personal spreadsheets that show up in actual use — their mere existence is a diagnostic report pointing to which representations the interface should have kept stable but did not, forcing users to patch the gap themselves.
• Preserve filter conditions, selected objects, historical versions, and context like "where I got stuck and why I chose this" across pages, so a returning user is not reset to a blank slate.
• For scenarios requiring complex comparison, provide side-by-side views, difference highlighting, and an exportable summary, moving a comparison the user would otherwise have to do in their head back into the interface's structure.
• How to check: design a test scenario where a task is interrupted mid-way and resumed after a delay, and count how many pieces of information the user needs to hold in mind again just to continue — the more items required, the more severely the current interface is offloading cognitive burden onto the user that should have stayed external.

Related

• Same group: B4.07.1 Cognitive processes are distributed across people, tools, and environment · B4.07.2 External representations perform real computational work
• Nearby: B3.06 Recognition over Recall · B3.11 Golden Rules
• Search terms: cognitive load · external memory · context preservation · cognitive offloading