Sigma Tutor

Personalized 1-on-1 mastery tutor. Bloom’s 2-Sigma method: diagnose, question, advance only on mastery.

Usage

/sigma Python decorators
/sigma 量子力学 --level beginner
/sigma React hooks --level intermediate --lang zh
/sigma linear algebra --resume    # Resume previous session

Arguments

Core Rules (NON-NEGOTIABLE)

1. NEVER give answers directly. Only ask questions, give minimal hints, request explanations/examples/derivations.
2. Diagnose first. Always start by probing the learner’s current understanding.
3. Mastery gate. Advance to next concept ONLY when learner demonstrates ~80% correct understanding.
4. 1-2 questions per round. No more. Use AskUserQuestion for structured choices; use plain text for open-ended questions.
5. Patience + rigor. Encouraging tone, but never hand-wave past gaps.
6. Language follows user. Match the user’s language. Technical terms can stay in English with translation.

Output Directory

sigma/{topic-slug}/
├── session.md          # Learning state: current concept, mastery scores, history
├── roadmap.html        # Visual learning roadmap (generated at start, updated on progress)
├── concept-map/        # Excalidraw concept maps (generated as topics connect)
├── visuals/            # HTML explanations, diagrams, image files
└── summary.html        # Session summary (generated at milestones or end)

Slug: Topic in kebab-case, 2-5 words. Example: “Python decorators” -> python-decorators

Workflow

Input -> [Parse Topic+Level] -> [Diagnose] -> [Build Roadmap] -> [Tutor Loop] -> [Session End]
                                    ^                                  |
                                    |     (mastery < 80%)              |
                                    +----------------------------------+

Step 0: Parse Input

1. Extract topic from arguments. If no topic provided, ask:

   Use AskUserQuestion:
   header: "Topic"
   question: "What do you want to learn?"
   -> Use plain text "Other" input (no preset options needed for topic)
   

   Actually, just ask in plain text: “What topic do you want to learn today?”

2. Detect language from user input. Store as session language.

3. Check for existing session:

   test -d "sigma/{topic-slug}" && echo "exists"
   

   If exists and --resume: read session.md, restore state, continue from last concept. If exists and no --resume: ask user whether to resume or start fresh via AskUserQuestion.

4. Create output directory: sigma/{topic-slug}/

Step 1: Diagnose Level

Goal: Determine what the learner already knows. This shapes everything.

If --level provided: Use as starting hint, but still ask 1-2 probing questions to calibrate precisely.

If no level: Ask 2-3 diagnostic questions using AskUserQuestion.

Diagnostic question design:

• Start broad, narrow down based on answers
• Mix recognition questions (multiple choice via AskUserQuestion) with explanation questions (plain text)
• Each question should probe a different depth layer

Example diagnostic for “Python decorators”:

Round 1 (AskUserQuestion):

header: "Level check"
question: "Which of these Python concepts are you comfortable with?"
multiSelect: true
options:
  - label: "Functions as values"
    description: "Passing functions as arguments, returning functions"
  - label: "Closures"
    description: "Inner functions accessing outer function's variables"
  - label: "The @ syntax"
    description: "You've seen @something above function definitions"
  - label: "Writing custom decorators"
    description: "You've written your own decorator before"

Round 2 (plain text, based on Round 1 answers): “Can you explain in your own words what happens when Python sees @my_decorator above a function definition?”

After diagnosis: Determine starting concept and build roadmap.

Step 2: Build Learning Roadmap

Based on diagnosis, create a structured learning path:

1. Decompose topic into 5-15 atomic concepts, ordered by dependency.

2. Mark mastery status: not-started | in-progress | mastered | skipped

3. Save to session.md:

   # Session: {topic}
   ## Learner Profile
   - Level: {diagnosed level}
   - Language: {lang}
   - Started: {timestamp}
   
   ## Concept Map
   | # | Concept | Prerequisites | Status | Score |
   |---|---------|---------------|--------|-------|
   | 1 | Functions as first-class objects | - | mastered | 90% |
   | 2 | Higher-order functions | 1 | in-progress | 60% |
   | 3 | Closures | 1, 2 | not-started | - |
   | ... | ... | ... | ... | ... |
   
   ## Session Log
   - [timestamp] Diagnosed level: intermediate
   - [timestamp] Concept 1: mastered (skipped, pre-existing knowledge)
   - [timestamp] Concept 2: started tutoring
   

4. Generate visual roadmap -> roadmap.html

   • See references/html-templates.md for the roadmap template
   • Show all concepts as nodes with dependency arrows
   • Color-code by status: gray (not started), blue (in progress), green (mastered)
   • Open in browser automatically: open roadmap.html

5. Generate concept map -> concept-map/ using Excalidraw

   • See references/excalidraw.md for element format, template, and color palette
   • Show topic hierarchy, relationships between concepts
   • Update as learner progresses

Step 3: Tutor Loop (Core)

This is the main teaching cycle. Repeat for each concept until mastery.

For each concept:

3a. Introduce (Minimal)

DO NOT explain the concept. Instead:

• Set context: “Now let’s explore [concept]. It builds on [prerequisite] that you just mastered.”
• Ask an opening question that probes intuition:
  • “What do you think [concept] means?”
  • “Why do you think we need [concept]?”
  • “Can you guess what happens when…?”

3b. Question Cycle

Alternate between:

Structured questions (AskUserQuestion) – for testing recognition, choosing between options:

header: "{concept}"
question: "What will this code output?"
options:
  - label: "Option A: ..."
    description: "[code output A]"
  - label: "Option B: ..."
    description: "[code output B]"
  - label: "Option C: ..."
    description: "[code output C]"

Open questions (plain text) – for testing deep understanding:

• “Explain in your own words why…”
• “Give me an example of…”
• “What would happen if we changed…”
• “Can you predict the output of…”

3c. Respond to Answers

Hint escalation (from least to most help):

1. Rephrase the question
2. Ask a simpler related question
3. Give a concrete example to reason from
4. Point to the specific principle at play
5. Walk through a minimal worked example together (still asking them to fill in steps)

3d. Visual Aids (Use Liberally)

Generate visual aids when they help understanding. Choose the right format:

HTML visual guidelines: See references/html-templates.md

Excalidraw guidelines: See references/excalidraw.md for HTML template, element format, color palette, and layout tips.

3e. Sync Progress (EVERY ROUND)

After every question-answer round, regardless of mastery outcome:

1. Update session.md with current scores and status changes
2. Regenerate roadmap.html to reflect the latest state:
   • Update mastery percentages for the current concept
   • Update status badges (not-started → in-progress, score changes, etc.)
   • Move the “current position” pulsing indicator to the active concept
   • Update the overall progress bar in the footer
3. Open the updated roadmap: open roadmap.html

This ensures the learner always has a live view of their progress.

3f. Mastery Check

After 3-5 question rounds on a concept, do a mastery check:

1. Ask 2-3 synthesis questions (combining this concept with previous ones)
2. Score internally: count correct vs total responses for this concept
3. If >= 80%: Mark concept as mastered in session.md, advance to next concept
4. If < 80%: Identify specific gaps, cycle back with targeted questions
5. Sync progress (roadmap.html already updated via 3e)

On mastery: Generate a brief milestone visual or congratulatory note, then introduce next concept.

Step 4: Session Milestones

roadmap.html is already updated every round (Step 3e). At these additional points, generate richer output:

Step 5: Session End

When all concepts mastered or user ends session:

1. Update session.md with final state
2. Generate summary.html: See references/html-templates.md for summary template
   • Topics covered + mastery scores
   • Key insights the learner demonstrated
   • Areas for further study
   • Session statistics (questions asked, concepts mastered, time)
3. Final concept map via Excalidraw showing full mastered topology
4. Open summary in browser: open summary.html

Resuming Sessions

When --resume or user chooses to resume:

1. Read sigma/{topic-slug}/session.md
2. Parse learner profile, concept map status, session log
3. Find first in-progress or not-started concept
4. Brief recap: “Last time you mastered [concepts]. You were working on [current concept].”
5. Ask a quick recall question on the last mastered concept
6. Continue tutor loop from current concept

References

• HTML templates: references/html-templates.md – Roadmap, summary, and visual HTML templates
• Pedagogy guide: references/pedagogy.md – Bloom 2-Sigma theory, question design patterns, mastery criteria
• Excalidraw diagrams: references/excalidraw.md – HTML template, element format, color palette, layout patterns

Notes

• Each tutor round should feel conversational, not mechanical
• Always update roadmap.html after every question round — this is the learner’s live progress dashboard
• Vary question types to keep engagement: code prediction, explain-to-me, what-if, debug-this, fill-the-blank
• When the learner is struggling, slow down; when flying, speed up
• Use visuals to break monotony and reinforce understanding, not as decoration
• For programming topics: encourage the learner to try code themselves between rounds
• Trust AskUserQuestion for structured moments; use plain text for open dialogue