Here's the boundary Chapter 1 left unnamed. Retrieval, spacing, interleaving — the harder route that pays off later — only work because there's room to do the work in.
That room is working memory, and it is small. Not metaphorically small: a tiny workbench, where a handful of new pieces get actively combined at once.
Struggle spent inside that workbench's limit is what teaches. Push past the limit and the exact same struggle stops teaching. There's no remaining capacity left to do anything productive with the added difficulty, so it just breaks the learner instead.
Locating that limit precisely — how small it really is, and what follows from it — is what the rest of this chapter is for.
Sweller's cognitive load theory (1988, 2010) puts a number on that workbench: you can hold about two to three novel, interacting elements in it at once.
Not two or three facts. Two or three things that have to be held together, each one depending on the others to make sense.
That distinction has a name — element interactivity: how many interdependent pieces an idea forces you to hold at once. Not how long its name is. Not how many words it takes to explain.
Ten unconnected facts are easy, because each one gets handled alone. A neural network's backward pass is hard for the opposite reason — node, weight, activation, output, and error have to be held together at once, five interacting elements minimum. That stays true no matter how simply any one sentence about it gets phrased.
Sweller, van Merriënboer & Paas (1998) split the demand on that workbench into three kinds. Managing them differently is the whole design discipline.
Intrinsic load is set by the idea itself — its element interactivity. It doesn't move unless what you're teaching changes, or how many pieces at once a learner has to hold changes.
Extraneous load is added by how the idea gets presented — a confusing diagram, a buried definition, a sentence with three clauses stacked on top of each other. None of it helps understanding. It's pure tax.
Germane load is the effortful work of actually building a schema: connecting a new idea to what's already known, testing it, noticing the pattern. You already have a name for this one. It's the same effort Chapter 1 called desirable difficulty — just described from the load side of the ledger instead of the practice side.
The design rule falls straight out of the split: minimise extraneous load, manage intrinsic load, protect germane load. Cut the tax. Respect the real difficulty. Don't let the productive struggle get cut along with the junk.
You already run a rule for exactly this trade-off: ideas at grade, syntax down — keep the concept at its real difficulty, strip the sentence around it down to something easy to decode. It's a good rule. Cognitive load theory can now tell you precisely what it does, and what it doesn't.
Shortening a sentence lowers extraneous load. It makes the sentence easier to decode, and that's real — it matters.
It does nothing to intrinsic load. A short sentence about a neural network's backward pass still forces node, weight, activation, output, and error to be held together at once. The idea's difficulty is fixed by what the idea is, not by the words wrapped around it.
The field's lever for intrinsic load isn't readability at all. It's sequencing, also called pre-training: teach the sub-elements in isolation first, until each one is familiar enough to stop counting as a separate item on the workbench. Only then combine them.
Once weight, activation, and error are each already familiar on their own, backpropagation stops being five new interacting things. It becomes one new relationship among things already held — the same content, restructured from a large intrinsic-load problem into a much smaller one.
Here's the trap this creates if you stop at the first half: assuming a shorter, simpler sentence around a hard idea has made the idea itself easier. It hasn't — not even partly.
A high-element-interactivity idea stays exactly as hard to hold in mind no matter how short the sentence describing it gets. Intrinsic load is fixed by how many interdependent pieces the idea forces you to hold at once, not by the words describing them.
Readability and sequencing are two different levers. They're easy to mistake for one, only because they both happen to matter for the same hard material — a genuinely difficult AI concept usually needs both a decodable sentence and its sub-elements taught first.
So the sharpening on your own ruling is specific: ideas at grade, syntax down stays correct as far as it goes, and it needs a second move sitting right next to it — sequence the high-interactivity ideas into sub-elements first, then combine. One rule was never going to cover two different kinds of load.
Cognitive load theory doesn't stop at sentences — it governs your diagram-density calls too, starting with a specific failure mode worth checking a page against by name.
When a diagram and the text explaining it sit physically apart — a caption block underneath, a callout off to the side — the reader has to search back and forth to connect them. Kalyuga, Chandler & Sweller (1999) call this split-attention. That search gets paid, in full, as extraneous load, every single time the eye jumps.
The fix is integration: put the label inside the figure, next to the thing it names, rather than below the figure in its own separate block.
Redundancy cuts the opposite direction. If a diagram is already complete on its own and the prose next to it just restates what's already visible, that prose doesn't help comprehension. It hurts it — now the reader has to reconcile two versions of the same information instead of reading one (Kalyuga, Chandler & Sweller, 1999).
More explanatory text is not automatically safer. Prose earns its place next to a diagram only by adding something the diagram can't show — cause, implication, the consequence — never by re-describing what's already there to see.
One more lever exists in the literature: modality, splitting the load across an audio and a visual channel. It needs sound, and print closes it off. Split-attention and redundancy are the two diagram levers you actually have on a page.
Between the two of them, your diagram-density instincts stop being a general feel and become two concrete, checkable rules: labels integrated into the figure, never floating below it; no prose that just restates a diagram already standing on its own. Both are things you can check a page against directly, not judgment calls.
A completely different design question turns out to have a sharp answer once element interactivity is in view: when should a learner be shown the solution, and when should they be made to find it themselves?
For a novice — someone with no existing schema for the problem type yet — studying a fully worked example beats solving an equivalent problem, for actually learning the method. Sweller & Cooper (1985) found problem-solvers took roughly six times as long as example-studiers to reach the same competence. A 2023 meta-analysis (Barbieri et al.) puts the general effect at g=0.48 — a solid, real advantage for worked examples.
The mechanism is specific, not a case for explaining less in general. Solving a new problem from scratch means searching — trying moves, backtracking, guessing at what applies. That search burns working memory without building the schema the learner is meant to keep. A worked example removes the search entirely, so the freed workbench space goes straight into noticing the pattern instead.
This isn't in tension with Chapter 1's desirable difficulty. Kirschner (2025) calls the relationship "hand in a glove" — cutting the extraneous, wasted search effort here is exactly what makes room for the productive, desirable kind of effort at the practice layer right after.
The worked-example advantage doesn't hold steady. It flips as a learner gains expertise. Kalyuga et al. (2003) found that once a learner already has a schema for a problem type, a fully worked example becomes redundant — re-explaining something already known adds load instead of removing it.
A 2025 meta-analysis quantifies the crossover directly: +0.51 favouring worked examples for low-knowledge learners, −0.43 favouring problem-solving for high-knowledge learners. Same intervention, opposite sign.
The qualifier that matters: expertise reversal is topic-local, not a trait a learner carries everywhere. The same learner can hold a real schema for one topic and have none at all for the next — genuinely reset to novice on it.
Grade level tells you almost nothing about which state a learner is in. What decides it is whether this specific learner already has a schema for this specific topic. Nothing broader than that.
If showing helps a novice and hurts an expert, a learner needs a way to move between the two states without a jarring jump. That bridge is backward fading, also called completion problems.
The method: start with a fully worked example. Next time, blank out the last step and have the learner supply it. Next time, blank two steps from the end. Keep shrinking what's given until the learner is solving the whole problem alone.
Renkl & Atkinson (2003, 2004) tested whether the direction of fading matters — blanking from the end backward, or from the start forward — and found it doesn't. What matters is that fading happens at all, gradually, rather than jumping straight from fully-shown to fully-independent.
This is close to what your own spiral rungs already do — worked example fading toward independent practice, even without this vocabulary for it. The correction the field adds is precision about where the fading happens: it should track topic-local prior knowledge, not the grade band a chapter sits in. A rung that assumes a reader is already past worked examples will be wrong exactly when that reader meets a genuinely new idea inside otherwise familiar territory.
One more misconception is worth naming before this chapter closes, because it looks like it should be safe by the chapter's own logic. Self-explanation is a germane-load technique — the productive, schema-building kind of effort — so it's tempting to assume that adding an "explain your reasoning" prompt to a worked example should help at any stage, including a learner's very first exposure to a topic.
It doesn't. Barbieri et al. (2023) found self-explanation prompts can actively hurt novices. Asked to explain something they don't yet understand, a novice generates explanations built on their own misconceptions — and those misconceptions get written down and rehearsed, not corrected.
Self-explanation needs something real already in place to explain. At the very first rung of backward fading — the fully worked example, before anything has been blanked — that something usually isn't there yet.
Pull back, and one limit is doing all the work in this chapter: a workbench that holds only two to three new, interacting elements.
Depending on where the load comes from, that one limit forces two different design responses. When the idea itself is complex, the answer is sequencing — teach the sub-elements first, then combine them. When the presentation is the problem, the answer is integration and restraint — labels inside the figure, prose that adds rather than restates.
A third axis runs orthogonal to both: whether a learner is a novice or already holds a schema for this specific topic. That state, not grade level, decides whether a worked example currently helps or hurts — and fading is the gradual bridge between the two.
Notice what happened along the way. Every one of these corrections landed on a ruling or a rhythm you were already running, not a competing system you had to adopt from scratch. The field mostly sharpened where to point effort you already knew was worth spending.