---
name: teach-me
description: >
  Walk the user through something until they actually understand it — layer by
  layer, one round at a time, every claim verified before it is taught. Use
  when the user asks to be walked through a design, codebase, requirement, or
  decision ("讲懂我", "给我讲讲", "teach me"), or wants to understand what
  exists from what was built. Also fires on handover from the think-twice
  skill after a second miss (a rewrite already failed).
---

# Teach Me

The user is present and can talk back: teaching is a loop, not a lecture. The
goal is their understanding, confirmed by them — never declared by you. An
explainer that re-explains everything, announces the matter settled, and
changes the subject has failed, even if every sentence was true.

The rule files referenced below — `double-check.md`, `self-contain.md`,
`style.md` — are parts of the **think-twice** skill; find them in that
skill's own directory. Where think-twice is not installed, the inline clause
at each pointer carries the rule's core.

## Loop

1. **Map and slice.** Build context from zero — the user starts as a **cold
   reader**: assume no earlier names or interfaces remembered. Split the subject into layers, ordered so each
   layer stands on the one before it. One layer per round.
2. **Check yourself before you teach.** Every claim in the layer follows
   `double-check.md` from the think-twice skill: verify it
   (read the code, run the command, open the source) or label it uncertain.
   When the stakes warrant, spawn a context-free subagent to blind-check a
   claim. Never teach a guess.
3. **Teach one layer.** Settled things are stated directly — not re-opened as
   questions. Express under `self-contain.md` from the think-twice skill: every
   term glossed at first use, examples drawn from material the conversation
   already holds — real files, real numbers, the user's own work — before any
   abstraction. Teach the subject, not the method: this skill's own vocabulary
   (layers, gates, loop) never appears in what the user reads. Chinese prose
   for a human reader also follows `style.md` from the think-twice skill:
   plain sentences over bold-label bullets, bold at most twice per paragraph,
   no filler connectives, no emoji.
4. **Route real decisions only.** Put to the user only what changes behavior,
   scope, or a public interface; digest implementation detail yourself. When a
   proper decision interview emerges, hand over to the grilling skill where
   installed; otherwise ask the decisions yourself, one per message, each with
   a recommended answer.
5. **The user gates the loop.** A round ends with one line — 这段讲了：plus a
   one-clause recap — then stop. No question attached, no preview of what
   comes next: the user's natural reply is the gate. Advance on "懂了"; stay
   on anything else. Never ask "clear?" — it gets a polite yes, and politeness
   is not information. On "没懂": first locate the stuck point — one question,
   with candidate options so answering is cheap (options belong here and only
   here) — then re-teach that same layer from a different angle: a concrete
   scenario walked start to end, a contrast with the thing it is most often
   confused with, the technical terms reattached last. Never change the subject
   yourself — when the user changes it, follow them, and pick the layer back
   up when they return.

   The final round closes differently: a short summary of everything taught,
   conclusion first — not a completion announcement.

## Done when

The user says they understand, or says it is enough. Nothing else ends the
loop — not your own judgement that the matter is settled.

## Out of scope

Multi-session curriculum learning (workspace, lessons, learning records) is
the `teach` skill, where installed. Rewriting one outgoing text is
`think-twice`. This skill is the live loop that gets a present user from
"没懂" to "懂了".