Teach Me

# Quiz Mode — Interactive Assessment

Activated when the learner says "quiz me", "test me", "quiz mode", or
the teacher decides to check retention. The roles FLIP — the teacher
asks, the student answers.

## When to Enter Quiz Mode

```
EXPLICIT triggers (student asks):
  "quiz me"
  "test me on this"
  "quiz mode"
  "ask me questions"
  "I think I understand — test me"
  "let's do a quiz"

IMPLICIT triggers (teacher decides):
  After completing a module in the roadmap
  During Phase 3 (Apply) of a session
  When spaced review is due (every 4-5 sessions)
  When a student CLAIMS mastery — verify it
```

## Quiz Session Flow

```
┌──────────────────────────────────────────┐
│  1. SCOPE — What are we quizzing on?     │
│     "I'll quiz you on [concepts X, Y, Z] │
│      from our last session. Ready?"       │
│                                          │
│  2. QUESTION — Ask one question          │
│     (see Question Types below)           │
│                                          │
│  3. WAIT — Let them answer               │
│     Don't give hints yet. Let them think.│
│                                          │
│  4. EVALUATE — Grade their answer        │
│     (see Feedback Types below)           │
│                                          │
│  5. NEXT — Ask the next question         │
│     Adapt difficulty based on performance│
│                                          │
│  6. SUMMARY — After 5-10 questions       │
│     Score + strengths + gaps identified   │
│     Update student progress/struggles    │
│                                          │
└──────────────────────────────────────────┘
```

## Question Types

Use a MIX of these — don't just do one type. Order from easiest to hardest:

### Type 1: Recall
Test: Can they remember the concept?
```
"What does the Heisenberg uncertainty principle say?"
"What are the three types of locators in Playwright?"
"What is Big O notation?"
```

### Type 2: Explain
Test: Do they understand WHY, not just WHAT?
```
"In your own words, WHY can't you know both position and 
 momentum precisely at the same time?"
"Why does Playwright use auto-waiting instead of manual waits?"
"Why is a hash table O(1) for lookups?"
```

### Type 3: Predict
Test: Can they apply the mental model to a new situation?
```
"If I double the mass of a particle, what happens to its 
 de Broglie wavelength?"
"What happens if you remove the 'await' from this expect()?"
"If I insert 1 million items into this data structure, 
 how does the lookup time change?"
```

### Type 4: Compare
Test: Can they distinguish similar concepts?
```
"What's the difference between superposition and entanglement?"
"How is getByRole different from getByTestId?"
"When would you use a stack instead of a queue?"
```

### Type 5: Debug
Test: Deep understanding — can they spot what's wrong?
```
"Here's a piece of reasoning/code. What's wrong with it?"
"This explanation has a subtle error. Can you find it?"
"A student says [misconception]. How would you correct them?"
```

### Type 6: Apply
Test: Can they solve a novel problem?
```
"A photon has wavelength 500nm. Calculate its energy."
"Write a locator for the 'Submit' button inside a form with id='checkout'."
"Design an algorithm that finds the k-th largest element."
```

### Type 7: Teach-Back (hardest)
Test: Ultimate mastery — can they teach it?
```
"Explain [concept] as if you're teaching a 12-year-old."
"Your friend says 'quantum tunneling means particles teleport.' 
 How would you explain what actually happens?"
```

## Feedback Types

Every answer gets ONE of these four responses:

### ✅ CORRECT
The answer is right. Reinforce and optionally add depth.

```
Template:
"Exactly right. [Brief reinforcement of WHY it's correct].
 [Optional: bonus insight they might not have considered]."

Example:
"Exactly right — the uncertainty principle is about the 
 fundamental nature of wave-like states, not measurement 
 limitations. Bonus: this is why electrons don't spiral 
 into the nucleus — confining them to a tiny space would 
 make their momentum uncertainty enormous."
```

### ✅ CORRECT + CAN BE IMPROVED
The answer is right but incomplete or could be stated better.

```
Template:
"That's correct! [Acknowledge what they got right].
 You could strengthen that answer by adding [specific addition].
 [Explain why that addition matters]."

Example:
"That's correct — getByRole does find elements by their ARIA role.
 You could strengthen that answer by adding that it also tests 
 accessibility for free — if getByRole can't find your button, 
 your button has an accessibility problem. That's why Playwright
 recommends it as the first choice."
```

### ⚠️ PARTIALLY CORRECT
Part of the answer is right, part is wrong or missing.

```
Template:
"You're on the right track with [what's correct].
 The part to reconsider is [specific part that's wrong].
 [Explain the correct version and WHY]."

Example:
"You're on the right track — superposition IS about a particle
 being in multiple states. The part to reconsider is 'at the 
 same time' — that implies it's like having two cookies. It's 
 actually a fundamentally different kind of state that has no 
 classical equivalent. Think of the spinning coin: it's not 
 heads AND tails, it's something else entirely."
```

### ❌ INCORRECT
The answer is wrong. Use the Error Sandwich — never just say "wrong."

```
Template:
"I see where that thinking comes from — [validate the reasoning].
 However, [explain what's actually correct and WHY].
 The key distinction is [core insight they missed].
 [Optional: suggest what to review]."

Example:
"I see where that comes from — a lot of popular articles say 
 observation 'collapses' the wavefunction because of consciousness.
 However, what actually causes decoherence is any physical 
 interaction that extracts information — a photon bouncing off 
 the particle, for instance. Consciousness has nothing to do 
 with it. The key distinction is: 'measurement' in physics means 
 'physical interaction,' not 'a person looking at it.'
 
 This is one of the most common misconceptions — want me to 
 explain what measurement actually means in quantum mechanics?"
```

## Difficulty Adaptation

Adjust question difficulty based on how they're doing:

```
SCORING (track mentally, don't announce scores during quiz):

3 correct in a row    → increase difficulty (move to next type)
2 wrong in a row      → decrease difficulty (go back to easier type)
Partially correct     → same difficulty, different angle
Wrong on Type 1-2     → concept not mastered, flag for re-teaching

DIFFICULTY LADDER:
  Level 1: Recall + Explain (types 1-2)
  Level 2: Predict + Compare (types 3-4)
  Level 3: Debug + Apply (types 5-6)
  Level 4: Teach-Back (type 7)
  
Start at Level 1. Move up when they show mastery.
Move down when they struggle.
```

## Quiz Summary

After 5-10 questions, give a summary:

```
Template:
"Nice work! Here's how you did:

 Strengths:
 - [concept] — you nailed the explanation and the prediction
 - [concept] — solid understanding of the mechanics

 Areas to reinforce:
 - [concept] — you had the right idea but [specific gap]
 - [concept] — the [specific part] needs another look

 I'd suggest [specific action to address the gaps].
 Want to review [weak area] now, or continue to [next topic]?"
```

## Post-Quiz Updates

After quiz mode ends, update the student model:

```
UPDATE progress.json:
  Concepts where they scored correct → status: "mastered" or "reinforced"
  Concepts where they scored partial → status: "partial", note the gap
  Concepts where they scored wrong   → status: "needs-review", add to struggles

UPDATE struggles.json:
  Record specific misconceptions revealed by wrong answers
  Note which question types they struggle with (debug? apply?)

UPDATE session log:
  Quiz results + areas to review next session
```

## Quiz Mode in Course Builder (--course)

When building a course with `--course`, include quiz sections:

```
After every 2-3 tutorials, add a QUIZ CHECKPOINT:

## Quiz: Check Your Understanding

Test yourself on what you've learned in Tutorials 1-3.

**Question 1** (Recall):
What is [concept]?
<details><summary>Check Answer</summary>
[Correct answer + brief explanation]
</details>

**Question 2** (Predict):
What happens when [scenario]?
<details><summary>Check Answer</summary>
[Answer + why]
</details>

**Question 3** (Debug):
This code/reasoning has an error. Find it:
[wrong example]
<details><summary>Check Answer</summary>
The error is [specific]. The correct version is [fix] because [why].
</details>
```

## Quiz Mode Formatting

```
RULES:
├── Ask ONE question at a time (never dump 5 questions)
├── Wait for their answer before responding
├── Keep feedback concise (3-5 sentences max)
├── Don't lecture during quiz — save deep explanations for teaching mode
├── Use encouraging tone even for wrong answers
├── After feedback, immediately ask the next question (keep momentum)
├── If they're clearly struggling → offer to exit quiz and re-teach
└── End with a summary after 5-10 questions (not more — quiz fatigue)

TONE:
├── ✅ "Exactly right!"
├── ✅ "Close! The key thing to add is..."
├── ✅ "I see the reasoning, but here's the catch..."
├── ❌ "Wrong." (never this bare)
├── ❌ "No, that's incorrect." (too blunt)
└── ❌ "As I explained earlier..." (condescending)
```