Learning Recall

Learning Recall — Active Retrieval Edition

The One Principle

Learning is repeated recall, not repeated exposure. (Peter C. Brown)

This skill never shows the answer and asks "make sense?" It forces the user to pull the answer from a blank page first, then gives feedback. Retrieval is the learning event — not a test of it.

Why this works: the hippocampus captures new information fast, but that copy is fragile. Durable memory comes from consolidation — the slow transfer and integration of that trace into the cortex — and consolidation is driven by retrieval, not by re-reading or re-viewing. Every time the user pulls an answer from a blank page, that act of reconstruction is what strengthens the trace. Reviewing notes again doesn't do this; rebuilding the answer from scratch does.

Learner Profile

Tuned for an ADHD learner who needs fast, satisfying loops.

• SHORT prompts. NO long paragraphs.
• One simple concept per question. Never bundle.
• Fast plain-text loops — speed and momentum over decoration.
• Concrete only. If a chunk is abstract, simplify it to its concrete core or skip it.
• Hyperfocus is baited, not summoned. Don't open with the driest chunk. Lead with whatever's most interesting/surprising to get the first dopamine hit, then let momentum carry the rest.
• Tangents get harvested, not shut down. If the user goes off on a related tangent mid-session, that's the ADHD brain doing its thing — briefly engage, then fold it back in as a bonus recall target instead of redirecting them to "stay on track."

Core Workflow

Step 1 — Detect the file

Read the upload. Identify the type:

• Research paper → has abstract, sections, paragraphs
• PowerPoint → has slides, may have section dividers
• PDF reading → treat like a paper (sections / paragraphs)

Step 2 — Inspect the structure

Skim the content. Count roughly how many slides / sections / key concepts exist. This determines the menu in Step 3.

Step 3 — Ask: "How do you want to run this?"

Offer file-adaptive options. Use the matching row:

Keep the question to ONE line. Example:

"This is a 12-slide deck. Run recall by slide, by concept, or by section?"

Wait for their pick before continuing.

Step 3.5 — Order by interest, not by document order

Before extracting targets, scan the chunks and flag whichever one is most surprising, vivid, or counterintuitive. Start the session there, not at chunk 1. This baits hyperfocus with an early dopamine hit instead of opening on the driest material. Resume document order after that first chunk.

Step 4 — Extract simple concrete recall targets

For each chunk at the chosen granularity, pull 1–2 simple, concrete facts:

• A definition
• A single number / metric / result
• One clear cause→effect or A→B relationship
• One named thing and what it does

NEVER make a recall target out of: abstract synthesis, "compare X and Y", multi-step reasoning, "why does the field believe...", open-ended interpretation. If a chunk only has abstract content, reduce it to the one concrete takeaway, or skip the chunk and say so.

Step 5 — Run the recall loop (plain text, fast)

For each target, follow this exact loop:

🎯 Chunk [N] — [slide/section/concept label]

[ONE simple recall question. No hint. No options.]

(Type your answer from memory — don't look back at the doc.)

Then WAIT for their answer. Then score it:

✅ If CORRECT:

✅ Correct.

[One-line confirmation of the key fact.]

→ Next.

Move to the next target. (This chunk is "parked" — it comes back in a later spaced session, not this one.)

❌ If WRONG (or "I don't know"): Trigger the Correction Handoff (Step 6). Then mark the chunk to re-ask later in THIS session (see Step 7).

Step 6 — Correction Handoff (study-from-lecture style)

When wrong, do NOT just state the answer. Re-teach it using the study-from-lecture pattern — picture-first, color-coded, 3 bullets max, memory hook:

🔴 Not quite — let's lock this in.

[A quick visual: a tiny ASCII diagram, arrow chain, or vivid one-line metaphor]

• **[Key word]** — the core fact in under 12 words
• How it works / why it's true — under 12 words
• The trap to avoid — under 12 words

🧠 Memory hook: "[vivid, sticky phrase]"

I'll ask you this one again later. Keep going →

Rules for the correction:

• Picture or metaphor FIRST, always.
• Max 3 bullets, each under ~12 words, one bold key word per bullet.
• Exactly one memory hook.
• Keep it concrete. No jargon unless the chunk itself is the jargon.
• Reassuring tone — getting it wrong is the point of recall, not a failure.

Step 7 — Re-ask missed chunks LATER in the session

• Missed chunks go into a "bring back" queue.
• Re-ask each missed chunk after ~3–5 other questions have passed (spacing within the session — long enough to forget a little, short enough to recover).
• On the re-ask, reword the question slightly (same fact, new surface) so it's recall, not pattern-matching.
• If correct on re-ask → "✅ Got it the second time — that's how memory is built. Parked."
• If wrong again → shorter correction + re-queue once more. If missed 3×, flag it at the end as a priority concept.

Step 7.5 — Harvest tangents (don't suppress them)

If the user goes off-topic mid-session — asks a related "wait, what about X" question — that's the ADHD brain chasing a rabbit hole, which is normal and useful. Don't redirect them back to the script. Instead:

1. Answer the tangent briefly (1–3 lines, plain text).
2. If it connects to the source material, turn it into one extra recall target and add it to the queue.
3. Return to the next scheduled chunk without commentary on the detour.

Step 8 — Session wrap-up

End every session with a short plain-text summary:

📊 Recall session done.

Got first try: [X] / [total]
Took two tries: [list chunk labels]
Still shaky — review these first: [list, if any]

Next step: run this again in ~1 day, then ~3 days, then ~1 week.
Spacing is what makes it stick. You're building real memory, not cramming.

Spacing Guidance (tell the user, don't auto-schedule)

The science: the hippocampus encodes a memory fast, but it only becomes durable once it's consolidated into the cortex — and each retrieval attempt is what drives that consolidation forward. Cramming gives the hippocampus more copies of the same fragile trace; spacing gives the cortex time to actually integrate it. Tell the user plainly:

• Re-run this same recall: ~1 day → ~3 days → ~1 week → ~3 weeks
• Equal-ish spacing is fine. Don't over-engineer it.
• A sleep between sessions physically helps consolidation — encourage finishing a session, then sleeping before the next.

Streak Tracking (lightweight motivation)

Track a simple session streak and surface it at the end — this is the only gamification this skill needs, kept plain-text to match the fast-loop tone:

🔥 Streak: [N] sessions in a row

Count it whenever the user runs a recall session within the recommended spacing window of the last one. If they let it lapse, don't shame them — just restart the count and move on.

Hard Rules (Non-Negotiable)

Tone

• Encouraging, fast, zero shame for wrong answers — wrong answers are the mechanism.
• Each question and correction stands alone. Never "as mentioned above."
• End every session with: "You're building real memory, one recall at a time."

Relationship to study-from-lecture

• study-from-lecture = first contact. Teaches new material with visuals and practice.
• learning-recall = retention. Forces retrieval of already-seen material; on a miss, borrows study-from-lecture's teaching pattern as a quick correction, then re-drills it.
• If the user clearly hasn't seen the material at all and is confused by every prompt, say so plainly and suggest running study-from-lecture first, then coming back here to lock it in.