Flow Learn New Topic

Learn a New Topic (Orchestrator)

Breadth-first onboarding. The goal is a usable map of an unfamiliar area: the core problems, the main method families, the key papers, and enough working intuition to start reading primary sources without drowning. This skill decides what to do next and which skill to hand to — it does not produce the teaching itself.

Contrast with siblings:

• flow-deep-understanding — depth-first mastery of one already-familiar object. Use it when breadth is no longer the bottleneck.
• flow-idea-to-proof — turning the user's own idea into a formal claim. Different goal entirely.

Before You Start: Locate the User

Ask only what you can't infer. You need:

• The target — what topic/method/field, stated concretely.
• Starting point — total novice, adjacent-field transfer, or "I've heard the words but nothing sticks".
• Purpose & depth — passing familiarity, ability to read papers, or ability to build. This sets how far down the pipeline to go.
• Time budget — a one-hour orientation vs a multi-week ramp changes everything.

If the target is vague ("I want to learn ML"), narrow it before routing — a map of an ocean is useless.

The Pipeline

Run these stages in order. Skip forward to wherever the user already is; not everyone starts at stage 1.

Orient → Map → Build intuition → Ground with toy cases → Read sources → Teach back

Gates are verified, not assumed. Each exit gate is checked with an exercise checkpoint: hand off to concept-exercise-generator to produce a short, graded easy-to-advanced problem set (with solutions in a separate file) targeting that stage's level. The user attempts it, self-scores against the rubric, and only then advances. A gate is met when the user clears the checkpoint's harder (Tier 3+) problems unaided — passing only the easy recall problems means re-study, not progress. Skip a checkpoint only when the user explicitly opts out or is clearly already past that stage.

Or verify the gate by discussion. A user who learns by explaining may clear any gate through a discussion round on that stage's material instead of an exercise set — see Discussion Mode below. The two verifiers are interchangeable per stage: exercises test whether the user can solve, discussion tests whether they can explain without borrowing. Neither is a soft option; both are cleared unaided or not at all.

Stage 1 — Orient (you, directly)

Give a one-screen lay of the land: what problem this area exists to solve, the 3–6 sub-areas inside it, and the names they'll keep hearing. This is a sketch to make later stages navigable, not a lecture. Exit gate: the user can name the major sub-areas and say which one they care about. Checkpoint: a Tier 1–2 set (recall the sub-areas, match terms to definitions).

Stage 2 — Map the landscape → literature-triangulation

Hand off to build a source-grounded map of the area: the canonical papers, the method families, the benchmarks, and the genuine disagreements. This prevents you from teaching a hallucinated consensus. Exit gate: there is a concrete reading list and a method-family map, with the user's target sub-area identified. Checkpoint: a Tier 1–2 set (which family solves which problem; which benchmark measures what).

Stage 3 — Build core intuition → professor-mentor-technical-teaching

For each core concept on the map, hand off to teach it properly: motivation → intuition → assumptions → formalism → limitations. Go concept by concept; don't dump the whole field at once. Exit gate: the user can explain why each core method exists and what pressure it responds to. Checkpoint: a Tier 3 set (why this method not that; what assumption breaks it) — this is the gate that actually verifies understanding; do not skip it.

Stage 4 — Ground with toy cases → theory-to-toy-cases

Turn the abstractions into the smallest concrete cases the user can compute or picture. Onboarding sticks when it becomes operational. Exit gate: the user has worked (or watched you work) at least one minimal example per core idea. Checkpoint: a Tier 2 + Tier 3 set (compute a fresh toy case unaided; predict what changes when an input is perturbed).

Stage 5 — Bridge to primary sources

Point back at the stage-2 reading list and have the user read the first canonical paper, now with enough scaffolding to follow it. Optionally hand off to theory-formalism-translator if the area's notation collides with a formalism they already know. Exit gate: the user can read a primary paper in the area without getting stuck on prerequisites. Checkpoint: a Tier 4 set on the actual paper (critique the central claim; derive a stated result; design an experiment that would falsify it).

Stage 6 — Teach the map back → naive-student

Have the user teach the core mechanism and its boundary to an honest novice. The student asks only confusion earned from the user's words and ends with a playback. Route any playback error back to the stage that should have supplied the missing dependency. Exit gate: the playback holds together and predicts one fresh case without the student silently repairing the explanation. In discussion mode the playback has been running since stage 1 — this stage is its summation over the whole map, not first contact with the student.

Discussion Mode

Some users learn by being the explainer rather than by reading and then testing. In discussion mode the user teaches the current stage's material to a cast of three, and the resulting playback clears that stage's gate in place of an exercise checkpoint. This is a gate mechanism, not a new stage: the pipeline above is unchanged, only how each gate gets verified.

The cast. STUDENT (naive-student) drives with earned questions. PEER (whiteboard-peer) challenges the user's answers. MENTOR (professor-mentor-technical-teaching) supplies a missing dependency, rarely. MODERATOR is this file — it rules each answer in one line and decides when to move on.

The professor splits three ways. Moderating is not teaching, and neither is grading. professor-critic must not fire during a discussion: it requires a finished artifact, a named reader, and an acceptance bar, none of which a live session has, and a verdict on unfinished thinking only demoralizes.

What each voice may know. The STUDENT may use only what has been spoken aloud in this session — never outside domain knowledge, which is its silent repair failure mode and would make the playback decorative instead of diagnostic. The STUDENT tags every link it accepts with [USER], [PEER], or [MENTOR]. PEER and MENTOR are unrestricted in knowledge but tightly restricted in timing and volume.

The round. STUDENT asks one question at the earliest unsupported link → USER answers first, always → PEER may then challenge (its default move), or assist with one partial move only if the user explicitly passes → MODERATOR rules CORRECT / INCOMPLETE: <what's missing> / WRONG: <the error> / STALLED → STUDENT records the source tag and asks the next question.

The escalation ladder. Never skip a rung:

USER answers → PEER challenges → USER retries → PEER partial move → MENTOR minimal dependency

Jumping straight to the mentor converts the discussion back into the lecture the user chose to avoid. Per round: one student question, one substantive peer move, one moderator line, at most one mentor dependency. If the mentor fires in two consecutive rounds, stop — the material is above the user's current footing, so drop back a stage rather than lecturing through it.

Passing the gate. The gate passes when the playback holds and every load-bearing link is [USER]-owned. A model that holds on borrowed links is a debt, not understanding: route those links to knowledge-debt-audit and re-run the round that should have established them.

Because this mode is breadth-first, keep each round scoped to one concept on the map. A discussion that sprawls across the whole area produces a playback too diffuse to localize any gap.

Handoffs Out

When breadth is no longer the bottleneck, route onward:

• One specific paper/method now needs rigorous mastery → flow-deep-understanding.
• They have an idea and want to formalize it → flow-idea-to-proof.
• They want to evaluate whether a method is actually good / find gaps → gap-finder or research-idea-stress-test.
• They can explain the map but want a peer on a half-formed extension → whiteboard-peer.
• They want the explanation itself judged → have them write it up as a finished piece first, then hand to professor-critic with a named reader and acceptance bar the user supplies — do not invent either. This is where the critic belongs: on a committed artifact after the discussion, never inside it.

Router Rules

• Delegate, don't duplicate. Each stage hands to a singleton skill; this file never re-teaches what that skill does.
• Resume, don't restart. Begin at the user's actual level. A returning user picks up at their last unmet exit gate.
• One concept at a time in stages 3–4. Breadth-first does not mean everything-at-once.
• Honor the depth target. "Read papers" stops at stage 5; "just curious" may stop at stage 3.
• Stop when the gate is met. Don't push the user through stages they don't need.
• Verify gates, don't assume them. Confirm each gate with a concept-exercise-generator checkpoint, or with a discussion round; advance only when the user clears it unaided. Generate the exercises there — never inline them here.
• In discussion mode, the user answers first. A peer that pre-empts the user destroys the diagnostic — the playback would then be grading the peer, not the user.