--- name: ckb-teach-me description: Turn the wiki into a personalised teaching curriculum — plan a single session or a spaced series (duration, frequency, optional .ics reminders), teach one portion per session using varied techniques, and track progress across calls, re-teaching weak spots first. Use for "teach me the wiki", "teach me about X", "run a teaching session", or "continue my lessons". --- # Teach me (wiki curriculum) skill ## Purpose Two modes, always in this order for a topic: **plan** (first call: scope, scheduling questions, session-sized portions, plan saved once accepted) and **teach** (every later call: next portion with a technique different from last time, retention spot-check of earlier sessions, progress updated). Never writes `wiki/`; curricula, plans and progress live under `outputs/teaching//`. ## How to run this skill ### Step 0 — Resolve topic and existing state 1. Determine the topic from the user's phrasing. "Teach me about X" scopes to X; a bare "teach me the wiki" scopes to the whole KB — confirm this is really what they want given it may be large, and offer to narrow it first (e.g. "the whole wiki is quite broad — want me to scope this to a part of it, or build a multi-session course covering all of it?"). 2. Slugify the topic (kebab-case) and look for `outputs/teaching//plan.md`. - **Exists** → this is a **Teach mode** call. Skip to Step 5. - **Doesn't exist** → this is a **Plan mode** call. Continue to Step 1. - **Several folders look like plausible matches** for a vague topic (e.g. user says "continue my lessons" with more than one curriculum in progress) → list them (topic, sessions done / total) and ask which one to continue. ### Step 1 — Scheduling questions (Plan mode only) Ask one at a time, waiting for each answer: **Q1 — Single session or a series?** > "Do you want this as one session, or a series of shorter sessions spread > over time?" **Q2 — Duration and frequency** - If single session: "How long should the session be? (e.g. 20, 45, 60 minutes)" - If series: "How long should each session be, and how often would you like them? (e.g. '20 minutes, twice a week' or '30 minutes every weekday')" Also ask for a start date if they want the calendar file (Q3) — otherwise it's optional and can default to "starting next session request." **Q3 — Calendar reminders** > "Would you like a calendar file (.ics) you can import to get reminders > for these sessions?" If yes and it's a series, also ask for a preferred time of day and start date if not already given, so events can be scheduled concretely. If it's a single session, offer a one-off reminder event instead. ### Step 2 — Gather the material 1. Read `wiki/index.md` (and `wiki/entities/index.md`, `wiki/graph/index.md` if present) to find every page in scope. For a narrow topic, use the cascade (local `wiki/` first, then `linked/`, then `libs/`) same as any query. For "whole wiki", scope is every page under `wiki/` plus its graph. 2. Read each in-scope page in full (`tldr` first — skip the body only if the page turns out irrelevant on inspection). 3. **Optional web supplement** — if the wiki is thin on a subtopic that's clearly needed for a coherent course, you may search the web to fill the gap. Mark any such material distinctly as *external, supplementary* in the plan and during teaching — it does not carry the wiki's cascade authority. If the gap is substantial enough to be worth keeping permanently, tell the user afterwards it would be a good candidate for `raw/inbox/` and a proper Ingest (per the Demand-Driven Context rule in `CLAUDE.md`) rather than silently folding it into the wiki yourself. 4. Use `wiki/graph/edges.json` (or link-following if edges are sparse — same fallback as the onboarding-tour skill) to work out dependency order: foundations (`depends_on`/`uses` targets) before the concepts that build on them. ### Step 3 — Chunk into sessions Order the material pedagogically (foundations → core → things that build on it, same logic as a guided tour), then cut it into session-sized portions against the duration from Step 1. - Rule of thumb: roughly one wiki page or tightly-scoped subtopic per 10-15 minutes of session time, adjusted for how dense the material actually is (a short stub page is quick; a long entity page with many facts takes longer). - **When in doubt, add a session rather than overfill one.** A session that runs long or crams two unrelated topics together teaches worse than two clean, focused sessions. Never let a single session's plan exceed its stated duration on paper. - Each session should have one clear theme/title, not a grab-bag. - Reserve implicit room in later sessions for retention spot-checks (Step 6) — don't plan every minute as new material. ### Step 4 — Present the plan and get acceptance Show the session breakdown before saving anything: ```markdown ## Proposed course: [Topic] **Format:** [N session(s) of ~M minutes] [ · every X, starting YYYY-MM-DD if series] **Calendar file:** [Yes — will generate reminders.ics / No] 1. **Session 1 — [title]** — [1-line: what it covers, sourced from which pages] 2. **Session 2 — [title]** — ... ... Sound good, or would you like the sessions rebalanced (more/fewer, different split)? ``` Wait for explicit acceptance before writing anything. If the user wants changes, adjust and re-present — don't save a rejected plan. ### Step 5 — Save the plan (Plan mode only, after acceptance) Create `outputs/teaching//plan.md`: ```markdown --- type: teaching-plan topic: scope: <"whole wiki" | narrower description> session_mode: single | series session_duration_minutes: frequency: calendar_file: outputs/teaching//reminders.ics | null created: YYYY-MM-DD last_updated: YYYY-MM-DD --- # Teaching plan: ## Overview [2-3 sentences: what this course covers and why the sessions are ordered this way.] ## Sessions ### Session 1 — - **Covers:** [pages/subtopics, as links, e.g. `wiki/entities/foo.md`] - **Learning goals:** [what the user should be able to explain/do after] - **External supplements:** [none | list, marked as such] ### Session 2 — <title> ... ``` Create `outputs/teaching/<slug>/progress.md` alongside it, empty of sessions so far: ```markdown --- type: teaching-progress topic: <topic as stated> plan_file: outputs/teaching/<slug>/plan.md last_updated: YYYY-MM-DD --- # Teaching progress: <topic> ## Session log _No sessions taught yet._ ## Next up Session 1 — <title>. ``` If a calendar file was requested, generate `outputs/teaching/<slug>/reminders.ics` (see Calendar file generation below). Report the paths written and that the course is ready to start whenever the user says so — do not start teaching Session 1 automatically in this same turn unless the user asks for it explicitly. ### Step 6 — Teach mode: pick up where progress left off 1. Read `plan.md` and `progress.md` for the resolved topic. 2. Determine the next unit of work: - If the previous session's knowledge check (see below) showed weak spots, open this session with a short, targeted recap of just those weak points before moving on — don't re-teach the whole prior session. - If the previous check was very poor (roughly under half recalled), dedicate this whole session to reinforcing that material instead of advancing the plan, and note this as an inserted repetition session in `progress.md` (it doesn't consume a slot from the numbered plan). - Otherwise, teach the next not-yet-completed session from `plan.md`. 3. Pick a teaching technique **different from the one used last session** (rotate through the list below) so the course doesn't feel repetitive. 4. Teach the portion: pull the actual facts from the relevant wiki pages (plus any marked external supplements), and deliver them via the chosen technique. Keep it interactive — this is a taught session, not a wall of text. 5. Close the session with a short, informal knowledge check (2-4 questions, open or quick-recall style) on **today's** material only. Judge generously, same spirit as the `quiz` skill: if the core fact came through even imperfectly, count it as understood. 6. Update `progress.md`: append a dated entry for this session (technique used, brief note on what was taught, knowledge-check result, any weak spots flagged for next time), update `Next up`, bump `last_updated` on both `progress.md` and — only if the plan's own shape changed (e.g. an inserted repetition session) — `plan.md`. 7. If this was the final session in the plan, say so, give a short overall verdict, and offer either a full-course review (can point at the `quiz` skill for a proper scored test) or planning a new topic. **Teaching technique rotation** (pick one not used last time; introduce variety, don't always default to plain explanation): - **Socratic questioning** — lead the user to the fact via guided questions rather than stating it outright. - **Analogy / storytelling** — frame the concept through a relatable comparison or short narrative. - **Worked example / case walkthrough** — walk through a concrete instance from the wiki step by step. - **Compare-and-contrast** — teach a concept against something it's commonly confused with. - **Teach-back** — give the user the raw facts, then ask them to explain the concept back in their own words; correct gently. - **Mnemonic / memory device** — for lists or sequences, build a memory aid together with the user. - **Real-world scenario / role-play** — apply the concept to a hypothetical situation the user reasons through. --- ## Calendar file generation Only when requested. Write a standard RFC 5545 `.ics` file to `outputs/teaching/<slug>/reminders.ics`: ``` BEGIN:VCALENDAR VERSION:2.0 PRODID:-//Cascade KB//Teach Me//EN BEGIN:VEVENT UID:<slug>-session-1@ckb-teach-me DTSTART:<YYYYMMDDTHHMMSS> DTEND:<start + session_duration_minutes> RRULE:<only if series, e.g. FREQ=WEEKLY;BYDAY=TU,TH> SUMMARY:Lesson: <topic> — Session 1 DESCRIPTION:<title of session 1> BEGIN:VALARM TRIGGER:-PT30M ACTION:DISPLAY DESCRIPTION:Lesson reminder END:VALARM END:VEVENT ...one VEVENT per session (or a single RRULE'd VEVENT if the sessions are evenly spaced and identical in duration)... END:VCALENDAR ``` - For a series with a regular cadence, prefer one recurring `VEVENT` with an `RRULE` (and a `COUNT=<N>` matching the number of sessions) over N separate events — simpler for the user's calendar app to manage. - For a single session or irregular cadence, emit one `VEVENT` per session with explicit dates. - Use the date/time the user gave in Step 1; if no time of day was given, ask before generating rather than guessing. - Tell the user the file path and that importing it is a manual step in their own calendar app — this skill only produces the file. --- ## Edge cases Unusual situations — an empty target, a partial run, a conflicting state, a missing dependency — are catalogued in [`references/edge-cases.md`](references/edge-cases.md). Read that file when a run hits something the steps above don't cover; don't load it otherwise.