Skin

Skin is the pass that reworks a rough map, with every source closed, into a structure memory can rebuild. It is the third move of the Bear Hunter System loop: Aim wrote the questions, Shoot drew the rough map, and this pass consolidates, integrates, and simplifies what those two built until the final chunk structure is settled. The pass ends when the map can be tested.

Before you change anything

A rough map arrives wrong in places, and it is supposed to: the earlier steps run fast and accept structural error, because getting every relationship right at first contact costs more than it returns. Corrections pile up as a topic grows — a few hours in, some piece already belongs somewhere else — and this pass cashes all of them at once.

Nothing new enters during this pass.

The work is rearranging what those steps captured, never adding, so the pass opens with questions: what the main backbone is, which chunks are overloaded or weak, which arrows matter, which parts still follow the source’s order, and which would be hard to rebuild from memory. The backbone — the few largest chunks and the flow between them, usually three to six for a whole topic — answers first, since a repair at the top makes every repair below it cheaper and details on an unclear backbone stay hard to retrieve.

The three repairs

Below the backbone the work is three repairs — split, merge, rename — and the first two share the 2–4 rule: a node wants two to four branches. More than four calls for sub-chunks; fewer than two is a single-node chain — one thing in, one thing out — which merges away, the survivor relabelled so the relationship reads straight. This is a working check, not a law of memory: roughly four items fit in the focus of attention, which is a reason crowded nodes are hard to hold, never a proof of the cutoff. It also works blind — branch counts find the spots even in an unfamiliar subject — and no move is final, since structure is a hypothesis and a removed chunk returns when new siblings appear.

Six points hang off one chunk. Splitting them into two sub-chunks of three does double
work: the relationship between the two new groups, which would otherwise cross the map
as a stray arrow, now sits inside the structure as the line between them.

The arrows read the same way: a map tangled in crossing arrows — spiderwebbing — has its cause in the structure, chunks lifted from the source’s own headings with the sideways relationships added afterwards, onto groups never built to carry them. The repair is a regrouping, because neater arrows leave the cause standing: the content goes back to a flat list, which strips the source’s grouping bias, chunks form around the relationships the list shows, and the map is drawn again minus the arrows not worth testing.

Renaming carries a test of its own: when the only way to remember what a group on the map holds is memorising the group itself, the label is doing no work — the tell is a term copied from the source. A label earns its place by naming what the group does or why it matters, and by naming the relation that makes those members a group rather than a new heading — a what set against a how. Even a competent textbook’s grouping usually needs the rearranging. One branch reading intuitively while its neighbour drops into jargon means a split can still improve, usually by grouping the underlying concept and letting the term ride along as a label.

The map shows	The repair
A node with more than four branches	Split into sub-chunks
A single-node chain	Merged away, the survivor relabelled
Arrows crossing chaotically	Re-chunked around the relationships
A vague or source-copied label	Renamed by what the group does
The source’s order showing through	Flattened to a list and rebuilt
A relationship stretched across the map	The two ends moved closer together
Pretty, and still not rebuildable	A closed-book brain dump, then repairs where it collapsed

Why the three are one move

A split, a merge, and a new label all force the same judgment: what matters most here, what comes second, and how the two relate. Getting from the rough map to the clean one is the step itself, and the importance judgments are the learning. Done well, arrows decrease while meaning increases: two far-apart ideas tied by a long arrow are two socks on opposite sides of a room joined with string, and in the same drawer the string is unnecessary. Grouping also cuts the cost of holding the material, since pieces carried alone are the first forgotten. Nothing leaves in the process — the finished map holds every detail of the rough one, nested a level deeper, which is the check that the no-new-input law held. The grouping craft itself — why two to four, why a label names a function — is defined at length in Importance-Based Chunking; this pass is where that craft lands on a finished map.

Turning the map into a test

The pass is not finished until the map can be tested.

The judgments hold only once they are checked, so the map’s last output is its prompt set: one prompt to rebuild the whole map from memory, one to explain each major chunk, one to explain the relations between the major chunks, one to rebuild a formerly overloaded area, one to compare two nearby concepts, and one to explain why the final chunk structure makes sense. Prompts like these aim retrieval practice at the structure rather than the facts, and practising retrieval of what was built beats another round of encoding it. The pass hands over the cleaned map — near-final structure, cleaner labels, reduced clutter, a visible backbone — with the prompts and a short list of gaps: the places that would not rebuild. The cleaned structure is what Spaced Interleaved Retrieval then takes on, testing it at lengthening delays.

When to run it, and what it costs

Those gaps also say when the next pass happens. Timing is a menu — the same day as the learning event, the week’s end for the week’s material, after a few Aim–Shoot cycles, before retrieval practice starts, whenever retrieval exposes a weakness — and it stays a menu because the pass is itself a form of interleaving and schedules like one. Size follows how much structure is actually wrong: ten minutes on the biggest problem is a real pass when time is short, and a map that comes out already logical needs no pass at all. A pass run a week later from pure recall doubles as revision that beats rereading, hunting through the familiar map for questions that cannot yet be answered — which surfaces the relationships the first pass missed.

A working pass makes the topic feel simpler: labels improve, crowded nodes become sub-chunks, single-node chains disappear, prompts start suggesting themselves. The warnings run the other way — only prettier, detail added instead of structure moved, the source’s order kept because it feels safe, still no rebuild — and behind all four sits the sunk cost of the hours already spent drawing. One bound keeps that warning honest: the failure is a redraw that changed no judgments, never a judgment that changed no drawing. The price is real, because re-chunking is the hard thinking of the loop, and quitting because it is hard is the live failure. On material with little internal logic the whole pass is optional — it degrades into pattern-hunting there, and the earlier steps carry the load. Polishing, by contrast, is the cheap move that still feels like work — the trade The Shortcut Problem names — and a map that looks finished but cannot be rebuilt is the case The Technique Is Only as Good as the Thinking It Produces describes.

When to stop

Stop when the map is good enough to retrieve from.

A pass reaches good enough when the map can support the retrieval loop, and the judge of that is the map’s fitness, never satisfaction with how it looks. Polishing past that line buys nothing, because the next repair is not found by looking harder. Retrieval finds it — the later pass from recall surfaces what this one missed. Once the map can be tested, the testing takes over.

Related Pages

• Deep Processing — the dimension this step belongs to: building material into structure rather than storing it as text.
• Bear Hunter System — the loop this is the third move of, and where the sequencing argument lives.
• Aim — the first move: the questions written before the material is understood, which is where the map’s relationships come from.
• Shoot — the second move, and the source of the rough map this pass cleans.
• Spaced Interleaved Retrieval — the test the cleaned map has to support, and the reason testability is the finish line.
• Self-Regulation — the control layer: noticing that a pass is going cosmetic while it is happening.
• Importance-Based Chunking — where the grouping craft is defined at length: why two to four, and why a label names a function.
• The Technique Is Only as Good as the Thinking It Produces — maps that look finished and cannot be reconstructed.
• The Shortcut Problem — polishing as the cheap move that feels like work.

Sources

• Tulving & Pearlstone (1966), and the category-clustering research that followed it — organised material is more retrievable than the same material left unorganised, which is the case for cleaning structure before testing it.
• Roediger & Karpicke (2006) — practising retrieval beats further encoding, which is why the pass ends in prompts and why a later pass from recall counts as revision.
• Cowan (2001) — the focus of attention holds roughly four items. Carried as a reason a node with five or more branches is hard to hold, not as a validation of the 2–4 rule.