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 — only a few independent novel units at once (plan around ~4 chunks; 3–5 is the safer current range — Miller's 7±2, revised by Cowan to ~4), and it holds novel information for only seconds unless rehearsed. CLT describes the load on that workspace in terms of intrinsic load (the task itself) and extraneous load (how you presented the task); germane load is the portion of working-memory effort that gets applied to building schemas out of the intrinsic material. 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 processing of intrinsic load, valuable) while keeping verbose prose around a table (extraneous load, wasteful). CLT gives a precise vocabulary for the tradeoff. Its deeper grounding is evolutionary (Geary's biologically secondary knowledge): we did not evolve to acquire reading, mathematics, or code effortlessly, so this material runs into the working-memory bottleneck and needs deliberate instructional design — unlike biologically primary skills such as speech or face recognition, which we acquire without it.

What it is NOT: Not a general UX heuristic. Not the same as plain-language writing. Not about reducing all complexity — germane processing (building schemas) is desirable and should not be starved. Not retrieval design (see context-management). Not a token-budget model, compression algorithm, or complete instructional-design theory.

Adjacent concepts: working memory, element interactivity, chunking, schema theory, dual-channel processing (Mayer's multimedia learning), segmentation principle, split-attention effect, redundancy effect, expertise reversal effect, transient information effect, context saturation, attentional residue, prompt overflow, tool-use capability boundary.

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 wastes the freed capacity that should go to schema-building. The correct target is extraneous load only.

Measurement note: Cognitive load is not just a metaphor — it is measured, classically with subjective rating scales (the Paas single-item mental-effort scale), dual-task performance, and physiological signals. This skill applies CLT as a design lens rather than running formal measurement, but the underlying loads are empirically tractable, not hand-wavy.

Cognitive Load Theory

Concept of the skill

Working memory is a small workspace with only a few independent novel units available at once — plan around ~4 chunks while remembering that estimates vary (3–5 is the safer range) and that expertise changes what counts as one chunk.

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, doc section, review comment, or agent output is imposing unnecessary cognitive load on its reader or user. The question is not "is it long?" but "what must the reader (or model) hold simultaneously, and why?" Do NOT use for retrieval and context-loading design (use context-management), token budget math and compaction timing (use context-window), 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, examples, and the modern post-2010 reframing of germane load as processing/resource-allocation.
• Element interactivity as the determinant of intrinsic load, and how it falls with expertise.
• Working-memory capacity and duration limits, the long-term-memory escape hatch, and expertise-dependent chunking.
• Segmentation, simple-to-complex sequencing, prerequisite activation, and progressive disclosure.
• The named CLT instructional effects (worked-example, split-attention, redundancy, modality, expertise-reversal, guidance-fading, completion-problem, goal-free, transient-information, isolated-elements, collective/collaborative working memory).
• A five-step diagnostic protocol; application to skill writing, prompt design, dashboards, docs, audit output, and agent responses.
• How the working-memory analogy transfers (and where it breaks) to LLM context, with 2024–2026 evidence.
• Current model-facing CLT stress tests as diagnostic patterns: CogniLoad-style independent manipulation of intrinsic difficulty, distractor density, and task length (including its U-shaped distractor response); ICE-style separation of context saturation from attentional residue; and ToolLoad-Bench-style tool-interaction graphs plus presentation-load capability cliffs for tool-use agents.
• Tool-use cognitive load (interaction-graph depth, oversized tool surfaces, raw tool-output sprawl) and multimodal presentation burden.
• Upstream-displacement checks for modern LLM capabilities: long context, multimodal context, structured outputs, prompt caching, deferred tool search, prompt-as-code, context editing / compaction, memory tools, prompt optimizers, stronger models, and subagents.
• A worked example reducing extraneous load in agent audit output; a measurement orientation; and common failure modes including the "simplify to lose germane content" trap.

This skill does not cover the full Mayer multimedia-learning research programme, formal load-measurement study design, assessment/test design, retrieval design, token accounting, prompt-security hardening, or copywriting style beyond what CLT directly explains.

Load Audit Kernel

When time or context is tight, apply this kernel before reading the full catalogue:

Default move: do not shorten first. Classify the load first, then remove only extraneous burden. (The full five-step Diagnostic Protocol in §5 expands this kernel; the kernel is the always-visible fast path before the theory catalogue.)

Philosophy of the skill

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. But CLT also prevents over-trimming: the goal is not minimum tokens; the goal is maximum useful comprehension within capacity.

CLT is also a living theory, not a 1988 relic. It has been refined repeatedly — the reconceptualization of germane load (Sweller 2010), the "20 years later" synthesis (Sweller, van Merriënboer & Paas 2019), and an explicit account (Sweller 2023) of how replication failures drove the theory's expansion rather than its collapse. Apply the current model, not the introductory-textbook caricature.

Cross-Domain Synergy

CLT is a theoretical foundation that neighboring skills draw on, but it owns load diagnosis, not their mechanisms. The table states both the help and the boundary so the synergy never drifts into a co-ownership claim.

1. When to Invoke CLT

Use this skill when the active question is about cognitive burden in material already chosen for presentation:

Do NOT invoke this skill for:

• Deciding what retrieval files to load or drop in a session (use context-management)
• Calculating token budgets, context health states, compaction timing, or model limits (use context-window)
• Writing the actual copy / prose (use writing-humanizer or microcopy)
• Choosing prompt phrasing strategies, provider role semantics, or structured-output API syntax (use prompt-craft)
• Compressing tokens, payloads, files, images, or long context (use compression)

2. The Load Model — 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. A task with many independent elements that can each be understood in isolation is low intrinsic load even if there are many of them; a task with few elements that all depend on each other is high intrinsic load. It is not the same as length — a short proof can be high intrinsic load; a long table of independent rows is low.

Intrinsic load is relative to the reader's expertise. Element interactivity is not a fixed property of the material — it falls as expertise rises. When several interacting elements are already stored as one schema in long-term memory, the reader treats them as a single element, so high-element-interactivity material becomes low-element-interactivity material (Sweller 2010). This is why the same page is dense for a novice and trivial for an expert.

Model-reader caveat (length is a separate channel, not intrinsic). The "length is not load" rule above is about intrinsic load for a human reader, and it stays correct: element interactivity and expertise — not raw length — determine what must be processed together. For an LLM or agent reader, raw sequence length is an additional, separable load channel even at zero interactivity: attention budget depletes per token and mid-context recall degrades regardless of how independent the rows are. CogniLoad (arXiv:2509.18458) makes this concrete — it tunes intrinsic difficulty (d), distractor-to-signal ratio (ρ), and task length (N) as independent dials and finds length a dominant constraint at fixed d and ρ; Du et al. (arXiv:2510.05381, "Context Length Alone Hurts LLM Performance Despite Perfect Retrieval") shows degradation as input length rises even when retrieval succeeds. So treat length as separate from intrinsic load, not as irrelevant: first ask whether the elements interact, then ask whether the reader is a model whose attention/search/generation path still pays for the full sequence. Do not corrupt the taxonomy — intrinsic load remains element interactivity; length is its own pressure. Route the token-budget half to context-window; CLT owns the diagnosis that the length is itself the 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).
• Isolated-elements first: For very high-interactivity material, teach the elements in isolation first (accepting temporarily incomplete understanding), then present them interacting once each is chunked.

Rule: Intrinsic load cannot be eliminated — the task is what it is. It can only be managed by sequencing, scaffolding, chunking, moving content behind prerequisites, and raising the reader's expertise.

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.

2.3 Germane Processing — the schema-building work applied to intrinsic load

Cognitive effort spent constructing, organizing, or automating a mental model. This effort is desirable — it is the mechanism of learning and skill acquisition. The goal is to free enough capacity (by removing extraneous load) that the reader can spend it on schema construction, while total load stays within capacity. It is not a blank check to add complexity: germane processing is valuable only when it helps the reader understand, transfer, or automate the material.

Rule: Eliminate extraneous load first. Use the freed capacity for germane processing only when the material's goal includes understanding, transfer, or future application.

2.4 Modern refinement — germane load is resource allocation, not a third tank

The introductory model presents three additive loads (intrinsic + extraneous + germane ≤ capacity). The current theory is more precise, and getting this right prevents a real reasoning error.

Sweller (2010), reaffirmed in the "20 years later" synthesis (Sweller, van Merriënboer & Paas 2019) and in Paas & van Merriënboer (2020), holds that germane load is not an independent source of load with its own knob. It is the portion of working-memory resources allocated to dealing with the intrinsic load — i.e., the effort that actually goes into building schemas from the task's interacting elements. (Kalyuga's 2011 critique made the same point sharply: "germane load" is redundant unless redefined as resources devoted to intrinsic rather than extraneous load.) The honest accounting is therefore:

Total load = intrinsic + extraneous. Germane load is how much of the capacity left after extraneous removal is genuinely devoted to the intrinsic material.

Why this matters for design:

• You cannot "add germane load" as a separate ingredient. You free capacity by cutting extraneous load, and you make germane processing likely by giving the reader something worth building a schema from (worked examples, varied cases, contrasts).
• "Promote germane" is shorthand for "remove extraneous so the freed capacity lands on schema construction, and present the intrinsic material so that construction is invited." It is causally correct under the modern model; the older additive phrasing is a teaching simplification.
• The practical checklist in this skill is unchanged by the refinement — but your reasoning about it should be: don't imagine a germane dial you can turn up independently of the task.

This is also why the original three-additive-bucket diagram survived as a teaching device: the practice (eliminate extraneous, protect schema-building structure) is identical. Use the additive picture to teach; use the allocation picture to reason. The traditional three-label vocabulary is retained throughout this skill for practical review and eval compatibility.

3. Working Memory and Chunking

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 (current human-AI CLT summaries phrase the bound as roughly 3–5 new units; plan around ~4). Treat the number as a planning heuristic, not a literal universal ceiling. 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. Working memory is also duration-limited: novel information decays within seconds unless rehearsed, which is why transient, scroll-away content is costly.

The deep asymmetry CLT rests on: working memory is severely limited for novel information, but effectively unlimited when drawing organized knowledge from long-term memory. Schemas in long-term memory are the escape hatch from the 4-chunk ceiling — the entire point of promoting schema formation.

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.
5. Move enforcement to structure: Tables, schemas, typed fields, and UI grouping reduce interpretation burden.
6. Support then fade: Keep worked examples for novices, then replace some solution steps with completion prompts when the reader has enough schema.

4. The Named CLT Effects (catalogue)

CLT is not one rule; it is a family of empirically established effects, each a specific instructional manipulation that lowers extraneous load or manages intrinsic load. Knowing the named effects turns vague "this feels heavy" intuitions into nameable, fixable diagnoses. Each row maps the effect to its agent-authoring application.

Note on expertise-dependence: most of these effects are novice effects — they appear for learners without the relevant schema and weaken or reverse as expertise rises (the expertise-reversal effect is the meta-statement of this). Always ask "who is the reader, and what do they already chunk?" before applying an effect.

5. Diagnostic Protocol

Use this five-step protocol before editing. Do not begin by shortening. Begin by classifying.

6. Application: Writing Skills

When authoring or reviewing a SKILL.md body, apply the three-load taxonomy to each section before cutting content.

Checklist

Writing skills for agents — the expertise-reversal caveat

A subtle trap specific to this library: the reader of a SKILL.md is usually a frontier model with enormous prior knowledge. For a topic the model already chunks, heavy worked examples and step-by-step scaffolding can become redundancy / expertise-reversal load — they restate what the model already holds and crowd out the genuinely novel content (the project's conventions, boundaries, and decisions). The fix is not to strip examples reflexively, but to ask which content is novel to a strong model: examples that encode this project's non-obvious choices are germane; examples that re-teach a well-known pattern the model already has are extraneous for that reader. Calibrate scaffolding to the novelty for the actual reader, not to a hypothetical beginner.

Runtime-loaded skills — progressive disclosure is not a license to bloat

Modern agent runtimes increasingly solve part of the load problem by loading skills on demand. Claude Code documents that a skill body loads only when used, OpenCode exposes skills through an on-demand native skill tool, and OpenAI's Agents SDK names skills as a progressive-disclosure primitive. This is a real upstream displacement of the old "put everything in the always-loaded instructions" pattern.

It does not remove CLT from skill authoring:

Skill-body rule: progressive disclosure reduces injection load, not comprehension load. Keep the body structured for the moment it is invoked, with a short kernel first and detailed reference material behind explicit links.

Body/reference budget rule: treat SKILL.md as the operating layer and sibling reference files as the source trail. First-party Claude skill guidance recommends keeping the main body compact and moving growing detail into directly linked files; the important CLT mechanism is not a universal line cap but one-hop progressive disclosure. A full skill can still preserve deep knowledge — the invoked body carries the kernel, boundaries, and decision procedures, while papers, source notes, long examples, and variant catalogues live in references the agent loads only when the task asks for them. Avoid nested reference trees: if SKILL.md points to a reference that points to another reference for the actual rule, the reader may inspect only the first hop and miss the substance. Do not delete curated knowledge merely because the body is large; preserve it behind a clear pointer unless it is wrong, redundant, or harmful.

Anti-patterns in skill bodies

7. Application: Designing Prompts and Agent Instructions

Prompt design is working-memory design for the model. The model's context window is not literally working memory, but the principles transfer functionally: a prompt that requires holding many interdependent instructions simultaneously creates a load-like degradation — drop, drift, or malformed output. Use CLT to decide when a prompt is overloading the processor; use prompt-craft for the exact provider tactics.

High-intrinsic-load prompt signals

CLT-informed prompt design

Does CLT actually transfer to LLMs? (what the 2024–2026 research shows)

The working-memory analogy is partly empirical now, with important caveats — state both honestly rather than asserting a clean equivalence:

• The model vendors now make the analogy first-party. Anthropic's Effective context engineering for AI agents (2025-09-29, published alongside Claude Sonnet 4.5 and Agent Skills) states it directly: "Like humans, who have limited working memory capacity, LLMs have an 'attention budget' that they draw on when parsing large volumes of context. Every new token introduced depletes this budget by some amount." Their guiding principle — "good context engineering means finding the smallest possible set of high-signal tokens that maximize the likelihood of some desired outcome" — is the LLM-side restatement of CLT's first rule: eliminate extraneous load before anything else. They name the degradation mechanism "context rot": as the number of tokens in the context window increases, the model's ability to accurately recall information from that context decreases. This is not a loose metaphor borrowed by a blog — it is the model provider's own design doctrine, which makes CLT's review lens more load-bearing for agent work, not less. (Boundary: the token-budget accounting this implies is owned by context-window; CLT owns the diagnosis of which load each retained token imposes.)
• The transfer is real but mechanistically different. An LLM has a bounded active workspace at inference: attention weights are spread across all tokens in a fixed context window, so every added token consumes attention budget. A recent framework (Overloaded minds and machines, Springer 2026, doi 10.1007/s10462-026-11510-z) maps Sweller's three loads onto this — intrinsic from task complexity, extraneous from poor structure and distractors, germane from productive in-context reasoning. The mechanism (finite biological working memory vs. distributed attention budget) differs, so treat it as a strong analogy, not an identity.
• Overload shows threshold, then collapse. As effective load rises (long dependency chains, poorly structured instructions, irrelevant distractors), accuracy holds up to a point and then degrades abruptly — the same shape CLT predicts for humans, and consistent with "lost-in-the-middle" / context-rot findings. Segmentation and distractor removal are load reductions, not just style.
• The two LLM load mechanisms now have names and numbers. The ICE benchmark (Interleaved Cognitive Evaluation, arXiv:2509.19517, 2025) deconfounds two distinct extraneous-load mechanisms and maps them onto the CLT taxonomy: Context Saturation — "extraneous, task-irrelevant information" — is the LLM form of extraneous load; Attentional Residue — "interference from task-switching" — is a load source this skill treats as first-class (it is why interleaving unrelated subtasks in one prompt degrades output even when the total token count is modest). The numbers show the threshold-then-collapse shape concretely: Gemini-2.0-Flash held 85% accuracy in the control condition but degraded significantly under saturation (β ≈ −0.003 per % load, p < 0.001), while smaller models (Llama-3-8B-Instruct, Mistral-7B-Instruct) scored 0% across all conditions on high-intrinsic-load multi-hop tasks — the cleanest available evidence that intrinsic load imposes a hard capacity ceiling, not a gradual slope, for weaker reasoners. The authors frame cognitive load as "a key contributor to reasoning failures, supporting theories of hallucination-as-guessing under uncertainty."
• All three CLT loads are now independently tunable dials in LLMs — and the dials behave unexpectedly. CogniLoad (arXiv:2509.18458, 2025) generates synthetic logic puzzles with factorial control over intrinsic difficulty (d), distractor-to-signal ratio (ρ, extraneous load), and task length (N, a proxy for germane-processing demand), then scores 22 reasoning models. Two findings refine this skill's guidance. (1) Task length is a dominant, independent constraint — performance falls with length even when intrinsic difficulty and distractor density are held fixed. For model-facing material, raw length is its own load dimension, not just a side effect of interactivity (see the §2.1 caveat). (2) *Distractor load is non-monotonic, and worst at intermediate intrinsic difficulty. On easy tasks added distractors barely hurt; at medium difficulty the accuracy trough widens and deepens before partially rebounding at very high distractor ratios — a U-shape, not a straight line. The actionable consequence: do not assume "fewer distractors is always proportionally better." The highest payoff from removing extraneous material is on moderately hard tasks, where the model has just enough capacity to be tipped over the edge; on trivially easy or already-saturated tasks the same cleanup buys less. This is the cleanest available evidence that intrinsic, extraneous, and length load are separable* in LLMs, which is the premise the whole skill rests on.
• Load can be weaponized. The "cognitive overload attack" (arXiv 2410.11272) deliberately inflates a model's effective load with long, nested context to slip past safety guardrails — a security reason to flag high-load presentation, connecting this skill to guardrails. A 2026 result, "Prompt Overflow" (arXiv:2605.23196), sharpens the mechanism: malicious instructions can be fragmented and interleaved with benign filler so no inspected segment crosses a local risk threshold, while the downstream LLM can still reconstruct the full intent — an inspection-execution mismatch between what a safety gateway reviews and what the model infers. (The paper's own terms are "Prompt Overflow", "risk-aware fragmentation", and "inspection-execution mismatch"; this skill describes the mechanism, not coined labels.)
• The analogy's limit. Humans apply metacognitive control — they notice overload and self-trigger strategies (take notes, simplify). Current models mostly need that scaffolding supplied explicitly in the prompt or workflow. So "design the model's working memory for it" is the actionable transfer; "the model will manage its own load" is not yet reliable.

Tool-use cognitive load

Tool-use is its own load surface, and 2026 evidence makes the mechanisms concrete. ToolLoad-Bench (arXiv:2601.20412) parametrically scales tool-use intrinsic load — formalized as a Tool Interaction Graph over the solution path (the dependency structure of the steps) — and extraneous load from ambiguous task/tool presentation and distractor tools, and finds each model has a distinct "cognitive profile": a baseline capability plus a load-sensitivity slope, with a sharp performance cliff once load crosses its boundary (the threshold-then-collapse shape, not a linear decline). Three distinct tool-use load sources follow, each with its own move:

1. Interaction-graph depth (intrinsic). When an agent starts dropping or hallucinating tool steps, do not only reach for a stronger model — first ask whether the interaction-graph depth of the task exceeds this model's cliff, and segment or externalize before that point. Splitting a deep tool chain across subagents can move it back under a model's cliff (or add merge load above it).
2. Tool-surface size (extraneous). A large catalog of tools/functions exposed up front forces the model to scan and hold many options before acting — distinct from any single tool's interaction-graph depth. Keep the initial tool surface small; defer large or rarely-used tools behind on-demand tool search / discovery (now first-party OpenAI guidance) so they load only when relevant.
3. Raw tool-output sprawl (extraneous). Forwarding raw, unfiltered tool output (a 5MB JSON blob, unparsed HTML) into active reasoning saturates the window. Distill raw results into the small set of facts, source paths, errors, IDs, and open unknowns the next step needs, before the next model call. (This raw-dump diagnosis is a general extraneous-load inference plus the direct purpose of Claude's tool-result clearing; ToolLoad-Bench grounds the interaction-graph, ambiguous-presentation, distractor-tool, and capability-cliff findings, not raw-output dumping specifically.) Boundary: context-management owns evidence selection and tool owners own result semantics; CLT diagnoses the sprawl.

Long-context evidence externalization

Long context is not the same as low load. Recent long-context studies show degradation even when the relevant evidence is present and retrievable (Du et al., "Context Length Alone Hurts LLM Performance Despite Perfect Retrieval", arXiv:2510.05381); one practical mitigation is to turn the long-context task into a short-context task by first extracting or reciting the decisive evidence, then solving from that compact workspace.

Use this CLT move when the model must reason over many interacting facts buried in a large context:

1. Retrieve or identify the evidence using the owning retrieval/context skill.
2. Externalize the decisive evidence in a short, persistent block: facts, source paths, constraints, and open unknowns.
3. Solve from that block, not from an instruction to "consider everything above."
4. Keep the evidence block visible next to the answer or tool call it supports.

Boundary: CLT owns the diagnosis that hidden long-context evidence is extraneous or high intrinsic load. context-management owns which evidence to select, context-window owns the token budget, and summarization owns the condensation mechanics.

Agent load matrix

Use this matrix to avoid treating all "model overload" as one thing. (It generalizes the named LLM mechanisms above — Context Saturation and Attentional Residue — into the broader agent-runtime load sources, each routed to its owning skill.)

Example: refactoring a high-load prompt

Before (high extraneous and intrinsic 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, makes the invalidity rule local to the classification step, gives severity an explicit schema, and provides a consistent schema for each step.

8. Application: UI / Dashboards

Per-screen cognitive budget is a CLT concept: a screen imposes load through the number of independent data points, interaction affordances, labels, legends, hidden state, visual weight, and task dependencies the viewer must process simultaneously.

Budget heuristics

Common dashboard extraneous-load sources

9. Modern Agent Capability Check

Run this upstream-displacement check before assuming CLT advice is obsolete because of a newer model or tooling feature.