Skin

Skin is the third move of the Bear Hunter System loop. Aim wrote the questions. Shoot drew the rough map. Skin reworks that rough map, with every source closed, into a structure that memory can rebuild.

The pass consolidates, integrates, and simplifies what the first two moves built, until the final chunk structure is settled. The pass ends when the map can be tested.

Core takeaways

• Nothing new enters during the pass. The work is rearranging what Aim and Shoot captured.
• Repair the backbone first: the few largest chunks and the flow between them, usually three to six for a whole topic. A repair at the top makes every repair below it cheaper.
• The three repairs are split, merge, and rename. Split and merge follow the 2–4 rule: a node should have two to four branches.
• All three repairs force the same judgment: what matters most, what comes second, and how the two relate. Those judgments are the learning.
• The pass is not finished until the map can be tested. Its last output is a set of prompts and a short list of the places that would not rebuild.
• Stop when the map is good enough to retrieve from. Polishing past that point gains nothing.

Why the rough map has errors

A rough map arrives wrong in places, and that is expected. The earlier steps run fast and accept structural error, because getting every relationship right at first contact costs more than it returns. Corrections accumulate as a topic grows. A few hours in, some piece already belongs somewhere else. This pass applies all of those corrections at once.

Nothing new enters during this pass.

The work is rearranging what those steps captured. Nothing is added.

Start with the backbone

The pass opens with questions. What is the main backbone? Which chunks are overloaded or weak? Which arrows matter? Which parts still follow the source’s order? Which parts would be hard to rebuild from memory?

The backbone is the few largest chunks and the flow between them, usually three to six for a whole topic. Answer the backbone question first. A repair at the top makes every repair below it cheaper. Details under an unclear backbone stay hard to retrieve.

The three repairs: split, merge, rename

Below the backbone, the work is three repairs: split, merge, and rename. Split and merge share the 2–4 rule: a node should have two to four branches. A node with more than four branches is split into sub-chunks. A node with fewer than two branches is a single-node chain, one thing in and one thing out. A single-node chain is merged away, and the surviving node is relabelled so the label states the relationship plainly.

The 2–4 rule is a working check. It is not a law of memory. Roughly four items fit in the focus of attention. That is a reason crowded nodes are hard to hold. It is not a proof of the cutoff. The rule also works on an unfamiliar subject, because branch counts find the weak spots without any knowledge of the content. No move is final. Structure is a hypothesis, and a removed chunk returns when new siblings appear.

Example: six points hang off one chunk. Splitting them into two sub-chunks of three does two things at once. The six points are now in groups of three. 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 the two groups.

Untangling crossing arrows

A map tangled in crossing arrows is called spiderwebbing. The cause is in the structure. The chunks were taken from the source’s own headings, and the sideways relationships were added afterwards, onto groups never built to carry them. Redrawing the arrows more neatly leaves the cause in place. The repair is a regrouping. Put the content back into a flat list, which strips out the source’s grouping bias. Form chunks around the relationships the list shows. Draw the map again, leaving out the arrows not worth testing.

Testing a label

A label has a test. If the only way to remember what a group holds is to memorise the group itself, the label is not helping. The usual sign is a term copied from the source. A label is doing its job when it names what the group does or why it matters. It also names the relation that makes those members one group. A heading names a topic. A label names how the members relate. Even a competent textbook’s grouping usually needs this rearranging. If one branch reads plainly and its neighbour is in jargon, the split can still improve. The usual fix is to group by the underlying concept and keep the term as the label.

What the map shows and what to do

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 repairs are one judgment

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. The move from the rough map to the clean one is the step. The judgments about importance are what gets learned. When the pass goes well, the map has fewer arrows and carries more meaning. Two ideas placed far apart on the map need a long arrow to show their relation. Placed in the same group, they need no arrow. Grouping also cuts the cost of holding the material, because pieces carried alone are the first forgotten.

Nothing is removed. The finished map holds every detail of the rough one, nested one level deeper. That is the check that nothing new entered. The grouping craft itself, why two to four and why a label names a function, is defined at length in Importance-Based Chunking. This pass is where that craft is applied to a finished map.

Writing the test prompts

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

The judgments count only once they are checked, so the last output of the pass is a prompt set. One prompt asks you to rebuild the whole map from memory. One asks you to explain each major chunk. One asks you to explain the relations between the major chunks. One asks you to rebuild an area that used to be overloaded. One asks you to compare two nearby concepts. One asks you to explain why the final chunk structure makes sense. These prompts point retrieval practice at the structure. They do not point it at the facts. Practising retrieval of what was built beats another round of encoding it.

At the end of the pass you have the cleaned map: near-final structure, cleaner labels, less clutter, and a visible backbone. You also have the prompts and a short list of gaps, the places that would not rebuild. Spaced Interleaved Retrieval then takes the cleaned structure and tests it at lengthening delays.

When to run the pass and how big to make it

The gaps say when the next pass happens. The timing has several options: the same day as the learning event, the end of the week for the week’s material, after a few Aim–Shoot cycles, before retrieval practice starts, or whenever retrieval exposes a weakness. The timing stays open because the pass is itself a form of interleaving and is scheduled like one.

Size follows how much of the structure is wrong. When time is short, ten minutes on the biggest problem is a real pass. A map that comes out already logical needs no pass at all. A pass run a week later from pure recall also serves as revision, and that revision beats rereading. The work in that case is going through the familiar map looking for questions that cannot yet be answered. That search surfaces the relationships the first pass missed.

Signs the pass is working, and signs it is not

A working pass makes the topic feel simpler. Labels improve, crowded nodes become sub-chunks, single-node chains disappear, and prompts come to mind without effort.

There are four warning signs: the map is only prettier, detail was added instead of structure moved, the source’s order was kept because it felt safe, and the map still cannot be rebuilt. All four come from the same cause: the sunk cost of the hours already spent drawing. One bound keeps that warning fair. A redraw that changed no judgments is a failure. A judgment that changed no drawing is not a failure.

The pass has a real price, because re-chunking is the hard thinking of the loop. Quitting because it is hard is the failure that actually happens. On material with little internal logic, the whole pass is optional. On that material it turns into pattern-hunting, and the earlier steps carry the load. Polishing is cheap and still feels like work. The Shortcut Problem names that trade. A map that looks finished and 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.

The map is good enough when it can support the retrieval loop. The judge of that is whether the map works for retrieval. How the map looks does not count. Polishing past that line gains nothing, because the next repair is not found by looking harder. The next repair shows up in retrieval practice. The later pass from recall surfaces what this one missed. Once the map can be tested, testing is the next step.

How to practice this

1. Close every source before you start. Find the backbone: the few largest chunks and the flow between them, usually three to six. Notice that once the backbone is right, each repair below it takes less work.
2. Count the branches on every node. Split any node with more than four branches, and merge away any single-node chain. Notice that branch counts find the weak spots even in a subject you do not know.
3. Where arrows cross, put that content back into a flat list and regroup around the relationships the list shows. Redraw the map without the arrows not worth testing. Notice how many of the old groups were the source’s own headings.
4. Read each label and ask whether it names what the group does. If you can only recall the group’s contents by memorising the group, rename it. Notice which labels are terms copied straight from the source.
5. Write prompts to rebuild the whole map from memory, explain each major chunk, and explain the relations between major chunks. Add prompts to rebuild a formerly overloaded area, compare two nearby concepts, and explain why the final structure makes sense. Notice which prompts you cannot yet answer; those places are the gap list.
6. Try a closed-book brain dump of the map. Notice where it collapses, and repair those places. Those gaps also set when the next pass happens.

Related pages

• Deep Processing: the dimension this step belongs to. It builds material into structure instead of storing it as text.
• Bear Hunter System: the loop this pass 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.

4 more related pages

• Self-Regulation: the control layer. Noticing that a pass is turning 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 rebuilt.
• 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. That is the case for cleaning structure before testing it.
• Roediger & Karpicke (2006): practising retrieval beats further encoding. That 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, and not as a validation of the 2–4 rule.