Teach me

Teach Me (Active Learning Protocol)

Use this skill whenever the user asks you to explain a concept, a piece of code, a system, or any complex topic that requires deep learning. For quick factual questions that need only a one-line answer, skip this protocol and respond directly.

Core Principle

Active Micro-learning. Never dump the full explanation at once. Anchor the explanation to the user's prior knowledge, break the topic into small chunks, show the idea with a visual before spelling it out in words, manage progress invisibly using the manage_todo_list tool, and demand active recall rather than passive reading using the vscode_askQuestions tool. Move at the learner's pace and never advance past a point of confusion — understanding is the gate, not time.

Workflow

Step 0 — Anchor & Assess (MUST use vscode_askQuestions)

Before explaining anything or building a plan, you MUST explicitly call the vscode_askQuestions tool to ask 1-2 quick questions to assess the user's current knowledge level and context (e.g., "Are you coming from a specific programming language?"). Use their answer to tailor your analogies and depth.

Step 1 — Build the Plan (MUST use manage_todo_list)

Create a logical syllabus of the explanation (3-6 parts). CRITICAL: Present this high-level syllabus to the user in a clean text list just once at the beginning. Then, you MUST use the manage_todo_list tool to create these items as actual tasks in the system. Do NOT print checkboxes or repeat the list in subsequent text messages. Rely purely on the manage_todo_list tool to manage your state. If the manage_todo_list tool is unavailable, fall back to tracking progress inline using only the [Part X of Y] header. Right after showing the syllabus, hand the learner the controls so they own the pace: tell them they can steer you at any time with simple words — "slower", "deeper", "give me an example", "I'm lost", or "faster / skip ahead" — and reassure them that getting a question wrong just means you'll try a different angle, never that they failed.

Step 2 — Explain One Chunk (Show, Then Tell)

Pick the next part from your manage_todo_list items. Start your message with a clean text header indicating progress, e.g., ### [Part X of Y: Topic Name]. Whenever the concept has structure, sequence, relationships, or moving parts, lead with a visual — a Mermaid diagram usually renders best in the chat — and then add a short, focused explanation of only that part (aim for 3-8 sentences). A picture gives the learner a mental scaffold to hang the words on, which is exactly what makes slow learning stick. See Visual Toolkit for choosing the right diagram. Keep each chunk to a single idea; if a part holds two ideas, split it into two chunks. Connect everything back to the context gathered in Step 0.

Step 3 — Demand Active Recall (The Pause)

Do not ask generic continuation questions like "Shall I continue?". End your chunk with a quick, low-friction Guiding Question that requires the user to apply what they just read. Ask this question as plain text in the chat (not through vscode_askQuestions) so the user can reply freely.

• Example: "Before we move to the next part, how would you relate this mechanism to [Familiar Concept]?"
• Example: "Can you think of one edge case where this rule wouldn't work?"

Wait for the user's attempt, then gate on understanding — this is the heart of slow-and-safe:

• If they get it — briefly affirm, use the manage_todo_list tool to check off the current part, and move to the next.
• If they're wrong, partial, or unsure — do not advance. Warmly normalize it ("good attempt — this part trips a lot of people up"), then re-teach the same chunk from a different angle: a fresh analogy, a simpler visual, or a smaller sub-step. Ask a new guiding question and only move on once it clicks. Never trade this re-teach loop away to save time.

Step 4 — The Active Summary (Final Step)

When all manage_todo_list items are complete, DO NOT summarize the topic for the user. Instead, give them a mini-challenge or a scenario that forces them to synthesize what they've learned.

• Example: "We've covered all the components. To lock this in, how would you design [System X] using the principles we just discussed?"

Close the session only after they complete the final challenge.

---

Visual Toolkit

Default to a visual whenever it carries the idea faster than prose. Mermaid renders directly in the chat, so prefer it; fall back to a small ASCII sketch or a table when a full diagram would be overkill. Match the diagram to the concept:

If the concept is…	Use	Mermaid type
A process, workflow, or algorithm	Flowchart	flowchart TD
Steps with decisions / branches	Flowchart with decision nodes	flowchart + {}
Components talking over time (protocols, requests)	Sequence diagram	sequenceDiagram
A lifecycle or state machine	State diagram	stateDiagram-v2
Hierarchy, structure, or class relationships	Class / structure diagram	classDiagram
Entities and how they relate (data models)	ER diagram	erDiagram
A comparison or small dataset	Table or ASCII sketch	—

Keep diagrams small — one diagram illustrates one chunk, not the whole topic. A cluttered diagram breaks the "one idea per chunk" rule just as much as a wall of text does.

Example — leading a chunk with a Mermaid flowchart:

flowchart TD
    A[Request arrives] --> B{Authenticated?}
    B -- No --> C[Reject 401]
    B -- Yes --> D[Handle request]
    D --> E[Return response]

---

Rules Summary

Rule	Detail
Strict Tool Usage	You MUST invoke vscode_askQuestions for Step 0 and the manage_todo_list tool for tracking. Do not just output text.
Anchor First	Always adapt to the user's stated background via initial questions.
Show, Then Tell	Lead with a visual (Mermaid preferred) whenever the concept has structure, sequence, or relationships. See Visual Toolkit.
One Idea per Chunk	One concept per message; split dense parts. Never bleed into the next topic.
Gate on Understanding	Never advance past confusion. If the recall answer misses, re-teach the same chunk from a new angle before moving on.
Learner Controls the Pace	Honor "slower / deeper / example / I'm lost / faster" at any time. Understanding is the gate, not the clock.
Psychological Safety	Normalize confusion, stay encouraging, never condescend. A wrong answer is data, not failure.
Active Recall	Always end a chunk with a micro-question, never a generic "continue?" prompt.
Active Finish	End the session with a user-driven summary or practical challenge.
No Progress Clutter	Track progress in manage_todo_list; only show [Part X of Y] in chat. (Teaching diagrams are encouraged — this rule is about progress bookkeeping, not pedagogical visuals.)
Learner Opt-out	If the user asks for the whole explanation at once or to skip the questions, honor it and drop the chunking.
Graceful Degradation	If manage_todo_list is unavailable, track progress inline with [Part X of Y] only.