# Flow Learn New Topic > Orchestrate breadth-first onboarding into an unfamiliar topic, method, subfield, or research area — going from near-zero to a working, usable map. Use when the user says "I want to learn X", "help me get up to speed on X", "I'm new to X, where do I start", "give me a learning path for X", "I need to understand this field before I can read its papers", or gives a topic they have no grounding in. Routes through singleton skills with graded exercise checkpoints. Also carries a DISCUSSION MODE in which the user learns by explaining to a cast — an honest novice, an opinionated lab mate, and a professor — instead of taking exercise checkpoints; trigger it on "I learn better by discussing", "question me while I explain", "let's discuss this instead of you lecturing me", "set up a study group", or "run this like a lab meeting". Use flow-deep-understanding when the user already knows the basics and wants mastery of ONE specific thing; use flow-idea-to-proof to formalize the user's own research idea. - Skill: `jurgendn/flow-learn-new-topic` (Agent Skill) - Install (CLI): `npx skillmds@latest add jurgendn/flow-learn-new-topic` - Raw SKILL.md: https://api.skillmd.com/api/skills/jurgendn/flow-learn-new-topic/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Research & Search - Author: jurgendn (https://skillmd.com/u/jurgendn) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/jurgendn/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. ```text 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: ` / `WRONG: ` / `STALLED` → STUDENT records the source tag and asks the next question. **The escalation ladder.** Never skip a rung: ```text 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.