Cognitive Load Theory

Concept Card

What it is: Cognitive Load Theory (CLT) is a psychological framework originating with John Sweller (1988) that explains how human working memory processes new information and what design decisions help or hinder schema formation. It is the scientific backbone behind "keep it simple" intuitions — but with actionable precision about which complexity to cut and which to preserve.

Mental model: Working memory is a small workspace — roughly 4 independent chunks at once (Miller's 7±2, revised by Cowan to ~4). CLT divides the total load on that workspace into three additive buckets: intrinsic (the task itself), extraneous (how you presented the task), and germane (the effort of building a mental model). Total load must stay below capacity or learning and comprehension fail.

Why it exists: Without CLT, agents default to "simplify" without knowing what to cut. They might remove worked examples (germane load, valuable) while keeping verbose prose around a table (extraneous load, wasteful). CLT gives a precise vocabulary for the tradeoff.

What it is NOT: Not a general UX heuristic. Not the same as plain-language writing. Not about reducing all complexity — germane load (building schemas) is desirable and should not be minimized. Not retrieval design (see context-management).

Adjacent concepts: working memory, chunking, schema theory, dual-channel processing (Mayer's multimedia learning), segmentation principle, split-attention effect, redundancy effect.

One-line analogy: CLT is like RAM management for humans — intrinsic load is the program you must run, extraneous load is unnecessary background processes, and germane load is the OS caching data so the next run is faster.

Common misconception: "Reducing cognitive load always means making things shorter or simpler." Wrong — cutting worked examples, removing context, or over-abstracting increases intrinsic load and destroys germane load. The correct target is extraneous load only.

Cognitive Load Theory

Domain Context

What is this skill? Sweller's Cognitive Load Theory for agents writing skill content, designing prompts, building UI/dashboards, and authoring documentation. Use when evaluating whether a skill body, prompt, UI screen, or doc section is imposing unnecessary cognitive load on its reader or user. Do NOT use for retrieval and context-loading design (use context-management), prompt engineering tactics (use prompt-craft), or instructional design beyond what grounds the theory here.

Coverage

The three-load taxonomy (intrinsic, extraneous, germane) with definitions and examples; working memory limits and chunking strategies; application to skill writing, prompt design, and UI/dashboard cognitive budgets; a worked example reducing extraneous load in agent audit output; and common failure modes including the "simplify to lose germane content" trap. Does not cover Mayer's multimedia learning extensions, split-attention effect research design, or assessment/test design.

Philosophy

Every agent output — a SKILL.md body, a prompt, a dashboard widget, a Linear comment — competes for space in the reader's working memory alongside everything else they hold. An agent that generates a 3-paragraph preamble before the actual answer forces the reader to hold that prose until they reach the substance. An agent that uses a consistent table format for comparative data lets the reader chunk the format into a single schema slot and spend their remaining capacity on the content. CLT is the theoretical justification for structure-over-prose, examples-before-explanation, and segmentation. Without it, quality guidance is cargo-culted. With it, agents can reason precisely about why a design choice reduces or increases cognitive burden.

Cross-Domain Synergy

CLT is the theoretical foundation that neighboring skills draw on implicitly:

• teaching-patterns: Uses CLT when choosing progressive disclosure (segmentation), worked examples (germane load promotion), and scaffolding removal.
• context-management: The discipline of controlling what enters a session is CLT applied to the agent's own working memory, not just the human reader's.
• context-window: Token budget management mirrors the working-memory budget — both measure available capacity against load.
• compression: Token-efficient compression is an application of extraneous-load elimination.
• editorial-standards: Structure-over-prose editorial rules are CLT operationalized for written output.

1. When to Invoke CLT

Use this skill when answering any of these questions:

Do NOT invoke this skill for:

• Deciding what retrieval files to load in a session (use context-management)
• Writing the actual copy / prose (use editorial-standards)
• Choosing prompt phrasing strategies (use prompt-craft)

2. The Three Load Types

2.1 Intrinsic Load — irreducible difficulty of the task itself

Determined by the element interactivity of the material: how many things must be held simultaneously because they interact with each other. High interactivity = high intrinsic load.

Management strategies:

• Segmentation: Break into sub-tasks where each segment can be completed before the next is shown.
• Prior-knowledge activation: Surface prerequisite concepts before the main material so they pre-load as chunks.
• Worked examples: Replace problem-solving with example-study while schemas are forming (reduces intrinsic load during early learning).

Rule: Intrinsic load cannot be eliminated — the task is what it is. It can only be managed by sequencing and scaffolding.

2.2 Extraneous Load — unnecessary load from poor presentation

Load that arises from the way the information is presented, not from the information itself. This is the only load type that should be aggressively eliminated.

Elimination tactics:

• Integrate labels directly into diagrams (remove the need to look between locations).
• Use tables for comparative data (reader chunks the format as a single schema slot).
• Remove decorative prose around already-clear structures.
• Apply consistent formatting so structure itself becomes a chunk the reader can ignore.

2.3 Germane Load — load that builds schemas

Cognitive effort spent constructing, organizing, or automating a mental model. This load is desirable — it is the mechanism of learning and skill acquisition. The goal is to maximize germane load within available capacity (total load ≤ capacity).

Promotion tactics:

• Include worked examples even when they lengthen the skill body.
• Provide multiple instantiations of abstract rules (varied examples increase schema strength).
• Use analogies that map onto known structures.
• Show failure modes alongside success patterns.

3. Working Memory Limits

The ~4-chunk finding

Cowan (2001) revised Miller's 7±2 downward: the reliable limit of working memory is approximately 4 independent chunks — not 7. Crucially, what counts as a "chunk" depends on expertise: an expert chess player chunks a board position into one unit; a novice processes each piece separately.

Implications:

Chunking strategies

1. Label by type, not by instance: Instead of 10 separate data points, introduce a category that chunks them (e.g., "fulfillment metrics" as a header that frames the following 5 rows).
2. Consistent structure as a free chunk: When every SKILL.md section follows the same format, the reader chunks the format itself — freeing all 4 slots for content.
3. Pre-load schemas: Front-load the concept card / summary so the reader builds a lightweight schema before encountering detail.
4. Segment before elaborating: Deliver the simplest complete unit first, add complexity in subsequent passes.

4. Application: Writing Skills

When authoring a SKILL.md body, apply the three-load taxonomy to each section before committing.

Checklist

Anti-patterns in skill bodies

5. Application: Designing Prompts

Prompt design is working-memory design for the model. The model's context window is not the same as working memory, but the principles transfer: a prompt that requires holding many interdependent instructions simultaneously creates functional equivalents of high cognitive load.

High-intrinsic-load prompt signals

CLT-informed prompt design

Example: refactoring a high-load prompt

Before (high extraneous load):

I need you to look at this audit output from our skill review system and think about which findings are the most important ones and then also consider whether any of them might actually be incorrect given the context of how skills work in our system, and then write a summary that could be used in a Linear comment explaining what needs to be done.

After (segmented, reduced extraneous load):

Step 1: Classify each finding below as VALID or INVALID. A finding is invalid if it misunderstands how our skill schema works.

[findings]

Step 2: Of the VALID findings, rank by severity: BLOCKING, ADVISORY, NITPICK.

Step 3: Write a Linear comment summarizing the BLOCKING findings and their required fixes.

The second version segments intrinsic load, removes preamble verbosity, and provides a consistent schema for each step.

6. Application: UI / Dashboards

Per-screen cognitive budget is a CLT concept: a screen imposes load through the number of independent data points, interaction affordances, and visual decisions the viewer must process simultaneously.

Budget heuristics

Common dashboard extraneous-load sources

7. Worked Example: Reducing Extraneous Load in Audit Output

Before (high extraneous load):

Audit Results for skills/my-skill/SKILL.md:

After reviewing the skill carefully I noticed that there are a few things that 
could be improved. The first issue I want to mention is that the description field 
in the frontmatter doesn't actually have the use_when and not_for patterns that 
we require. Also, looking at the relations section, I see that verify_with is 
empty which means the skill has no verification partners. Additionally, the eval 
file has only one eval which is below the minimum we set.

I think these should be fixed but the skill is otherwise in reasonable shape.

After (low extraneous load, structured):

## Audit: skills/my-skill/SKILL.md

| Finding | Severity | Fix |
|---------|----------|-----|
| description missing use_when / not_for pattern | BLOCKING | Add "Use when: ... Do NOT use for: ..." |
| relations.verify_with is empty | ADVISORY | Add at least one verify_with skill |
| evals/evals.json has 1 eval (min: 2) | BLOCKING | Add a second eval case |

Overall: 2 BLOCKING. Fix before marking PASS.

What changed:

• Removed verbal preamble ("After reviewing the skill carefully I noticed...")
• Replaced prose with a table — each finding is now one chunk
• Made severity and fix explicit rather than embedded in prose
• Removed hedging ("I think", "otherwise in reasonable shape") — extraneous load with no information content

8. Common Failure Modes

9. Rating Criteria

Rate any output (skill body, prompt, doc section, dashboard widget) against CLT:

Health Block

The four-verdict shape is per ADR 0011. All four verdicts default to UNVERIFIED on a fresh port; gates 1–8 and the application-eval pilot populate them in subsequent audits.

Do NOT Use When