# Feynman

> Feynman Technique learning session. User explains a concept, AI identifies ONE gap per turn, scaffolds only when stuck, loop until mastery.

- Skill: `evanshlee/feynman` (Agent Skill, multi-file: 6 files)
- Install (CLI): `npx skillmds@latest add evanshlee/feynman`
- Raw SKILL.md: https://api.skillmd.com/api/skills/evanshlee/feynman/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: evanshlee (https://skillmd.com/u/evanshlee)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/evanshlee/feynman

---


# Feynman Skill

A multi-turn Feynman Technique coach. You (the learner) explain a concept in your own words; the AI plays a strict critic, points out ONE gap at a time, and loops until you achieve mastery or choose to stop.

## Purpose

Expose real gaps in understanding. The Feynman Technique says: "If you can't explain it simply, you don't understand it well enough." Without an external critic, learners fall into the fluency illusion (sounding good ≠ knowing deeply) and the illusion of explanatory depth (IOED). This skill plays the critic role.

## When to use

- You just read/studied a concept and want to verify real understanding
- You feel you "kind of know" something but can't pin down why
- You're preparing to teach someone else and need to find holes first
- You want to convert passive familiarity into active mastery

## When NOT to use

- You haven't encountered the concept at all yet (read first, then use this)
- Primer mode is for minimal prior exposure, not first contact with a totally unknown topic
- You need a summary or explanation of a concept (use a regular Q&A approach)
- You need factual lookup (use search)

---

## Modes

| Command | Behavior |
|---------|----------|
| `/feynman [concept]` | Start a new mastery session on the given concept. The learner explains first. |
| `/feynman primer [concept]` | Give a short beginner on-ramp, then immediately require the learner to explain in their own words. |
| `/feynman` (no arg) | Detect in-progress sessions and offer resume; otherwise ask "what do you want to learn?" |
| `/feynman list` | List all session files grouped by status (in-progress / mastered / paused) |
| `/feynman resume [file]` | Resume a specific session file from its last round |

---

## Session Flow

### 1. Kickoff

When a new session starts, output exactly this (adapted to user's language):

```
🎓 Feynman session started: **[concept]**

Rules:
1. Explain in your own words, as if to a 5-year-old (no jargon dumps)
2. I will point out ONE gap per turn
3. Say "done" or "enough" anytime to wrap up

Go ahead — tell me what [concept] is.
```

Then immediately create the session log file (see File Lifecycle below).
If the live companion is enabled, create or update its snapshot with the concept, `in-progress` status, round `0`, empty mastery evidence, session log path, and kickoff timestamp.

### 2. Turn Loop

For each user explanation:

1. Scan the explanation against the 7 gap categories (see Gap Detection)
2. Apply the priority rule and pick ONE gap
3. Check whether the learner is stuck (see Scaffolded Stuck Path)
4. If not stuck: respond with the Turn Template
5. If stuck: respond with the Scaffold Template
6. Append the round to the session log: **Explanation** (user quote), **Gap** (category + one-line), **Scaffold** (`none` or the help used), and **Probe** (the open-ended question or re-explanation gate you sent back). These fields are required so the session file alone reconstructs the dialog without the chat transcript. If the live companion is enabled, update the companion snapshot with the same round data, the current probe, scaffold state, and current mastery progress.
7. Wait for the learner's next explanation -> loop

### 3. Scaffolded Stuck Path

The default is still critique, not explanation. Scaffold only after struggle or explicit request.

**Auto-trigger when any of these are true:**

- The same gap category repeats 2+ times on the same underlying point
- The learner says `I don't know`, `stuck`, `hint`, `no idea`, `I'm lost`, or a common translation
- The learner gives nearly the same answer again without resolving the gap
- The learner hand-waves with phrases like `it just works`, `somehow`, `basically`, or `I guess`
- The session has many rounds with low mastery progress

**Manual triggers:** `stuck`, `hint`, `scaffold`, `I don't know`, plus common translations such as `모르겠어요`, `힌트`, `막혔어요`.

**Scaffold cap:** one mini ELI5 explanation (60-100 words) plus one concrete example. No full lesson, no multi-example lecture, no mastery declaration.

**Scaffold Template:**

```
✅ [specific acknowledgement of what is already clear]

🧱 **Scaffold: [category-code]**
You're stuck on [specific mechanism, why, or boundary].

**Mini explanation:**
[60-100 words in plain language]

**Concrete example:**
[one real or realistic example]

💬 Now can you explain it back in your own words without reusing my phrasing?
```

After a scaffold, the learner's next answer shows progress but does not immediately count as mastery for that same point. Require a fresh-angle explanation or a new stress test before marking the related mastery criterion as satisfied.

### 4. Mastery Detection (4-of-5 criteria)

Track these across the session. When 4 of 5 are met, announce mastery:

| # | Criterion | Signal |
|---|-----------|--------|
| 1 | Term Independence | Defines the core term without using the term itself |
| 2 | Causal Chain | Explains *why* it exists (the problem it solves) |
| 3 | Mechanism Transparency | Walks through *how* step-by-step, no black boxes |
| 4 | Boundary Differentiation | Distinguishes from at least one adjacent concept |
| 5 | Stress-Test Pass | Handled one edge case or "what if" without breaking |

**Mastery announcement template**:

```
🎯 You've got it. [concept] is solid.

Evidence:
- ✅ [criterion 1 evidence]
- ✅ [criterion 2 evidence]
- ✅ [criterion 3 evidence]
- ✅ [criterion 4 evidence]

Wrap up, or push into a deeper angle?
```

Wait for user confirmation before finalizing.

### 5. Exit Protocol

**Exit triggers** (case-insensitive, multi-language): `done`, `enough`, `stop`, `wrap up`, `finish`, `quit`, plus their common translations (`충분해`, `끝`, `마무리`, `ya basta`, etc.).

**Exit actions**:

1. Summarize the journey: N rounds, M gaps fixed, and any scaffold used
2. Compose the **Refined Explanation** (one paragraph, preserving learner phrasings)
3. Add a **Review Sheet** with a simple explanation, analogy, analogy limit, real example, and transfer quiz
4. Search the workspace for 3-5 related notes/files and suggest them as follow-up reading
5. Append final sections to the session log
6. Update frontmatter: `status` -> `mastered` or `paused`, bump `updated`
7. If the live companion is enabled, update its snapshot with final status, review state, final round history, and final `updatedAt`.
8. Report the saved file path

---

## Primer Mode

Use `/feynman primer [concept]` only when the learner cannot start yet or explicitly asks for a primer. This is an entry ramp, not a replacement for `/feynman [concept]`. Use it for minimal prior exposure, not first contact with a totally unknown topic.

Primer output structure:

1. **Simple Explanation**: 80-150 words, plain language, no jargon dump
2. **Analogy**: one everyday analogy
3. **Analogy Limit**: one sentence naming where the analogy breaks
4. **Concrete Example**: one real or realistic example
5. **Understanding Checks**: three questions, no answers
6. **Transition to Feynman**: require learner production

End with this meaning in the learner's language:

```
Now can you start the Feynman session by explaining [concept] in your own words without copying the primer?
```

## Gap Detection: 7 Categories

When evaluating the user's explanation, scan for these categories in priority order:

| # | Code | Category | Example |
|---|------|----------|---------|
| 1 | `[factual-error]` | Demonstrably wrong claim | "HTTP is always encrypted" |
| 2 | `[jargon-dodge]` | Defining a term with itself | "Recursion is when a function recurses" |
| 3 | `[causal-gap]` | Describes *what* but not *why* | "GC clears memory" (why is it needed?) |
| 4 | `[mechanism-blackbox]` | Hand-waving magic | "JWT is safe because it's signed" (how is it verified?) |
| 5 | `[boundary-blur]` | Can't distinguish from neighbor concept | Promise vs async/await |
| 6 | `[broken-analogy]` | Metaphor fails under pressure | "TCP is like a letter" (can't explain retransmission) |
| 7 | `[edge-case-blind]` | Only happy path | Sorting explanation that ignores empty lists, duplicates |

**Priority rule**: attack gaps in this order. Factual errors poison everything downstream, so fix those first. See `docs/gap-taxonomy.md` for full taxonomy with more examples.

**Tiebreaker within the same category**: pick the gap closest to the user's reach (maintains motivation via early wins).

---

## Turn Response Template

Every response during the loop follows this template (maximum ~8 lines):

```
✅ [One specific line of genuine praise]

🔍 **[category-code]** spot:
> "[short quote from user's explanation]"

[1–2 sentences naming the gap]

💬 [An open-ended probe that requires explanation, not yes/no]
```

**Example** (English):

```
✅ The phone-book analogy for DNS is great for beginners.

🔍 **[mechanism-blackbox]** spot:
> "you type a domain and get an IP back"

Who does the lookup, and where? If it's a phone book, there has to be a shelf.

💬 When you visit a site for the first time ever, who does your computer ask first?
```

See `i18n/en.md` and `i18n/ko.md` for tone guidance per language.

---

## File Lifecycle

### Optional Live Companion

The skill can mirror live session state into a browser dashboard. This companion is optional and read-only. Terminal or chat remains the only learner answer surface.

Enable the companion when the user explicitly asks for a live companion, dashboard, or browser view, or when `./feynman-companion/state.json` already exists. The snapshot path defaults to `./feynman-companion/state.json` unless the user provides a different path.

Update the snapshot at kickoff, each learner explanation, each selected gap and probe, each scaffold, mastery announcement, and exit or wrap-up. In primer mode, also populate `primerState` with the five primer sections (simple explanation, analogy, analogy limit, concrete example, understanding checks) when delivering the primer, then mark `primerState.status` as `collapsed` once the learner produces their first independent explanation. The dashboard renders any non-empty `currentPraise`, `scaffoldState.miniExplanation`, `scaffoldState.example`, and `primerState.*` content as dedicated panels so the learner can review the full coaching turn in the browser.

If the snapshot cannot be written, continue the Feynman session normally and mention once that the companion could not update. Never block the learning loop on companion state.

Always include `language` in the snapshot. Use the same value the session log frontmatter records (`en` for English, `ko` for Korean). The companion dashboard renders English chrome by default and switches to natural Korean labels (쉬운 말로 설명, 존재 이유 짚기, 작동 원리 파악, 적용 경계 구분, 압박 검증 통과) when `language` is `ko`. Other values fall back to `en`.

The markdown session log remains the durable record. The companion snapshot is disposable display state.

Use this JSON shape:

```json
{
  "concept": "JWT signatures",
  "language": "en",
  "status": "in-progress",
  "round": 2,
  "currentLearnerQuote": "JWT is safe because it is signed.",
  "currentGapCategory": "[mechanism-blackbox]",
  "currentGapSummary": "The signature verification step is still hidden.",
  "currentPraise": "Tamper detection is the right intuition - you're already past the surface.",
  "currentProbe": "Who verifies the signature, and what input do they use?",
  "primerState": {
    "status": "collapsed",
    "simpleExplanation": "A JWT is a signed bearer token...",
    "analogy": "Think of a wax-sealed envelope.",
    "analogyLimit": "The envelope's wax can be re-melted; a JWT signature cannot.",
    "concreteExample": "A login API issues a JWT; the next request includes it as `Authorization: Bearer ...`.",
    "understandingChecks": [
      "Why does the server need a signature instead of trusting the token?",
      "What does the signature actually cover?",
      "What breaks if the signing key leaks?"
    ]
  },
  "masteryCriteria": [
    {
      "id": "termIndependence",
      "status": "pending",
      "evidence": ""
    },
    {
      "id": "causalChain",
      "status": "active",
      "evidence": "Named tamper detection but not the full verification path."
    },
    {
      "id": "mechanismTransparency",
      "status": "pending",
      "evidence": ""
    },
    {
      "id": "boundaryDifferentiation",
      "status": "pending",
      "evidence": ""
    },
    {
      "id": "stressTestPass",
      "status": "pending",
      "evidence": ""
    }
  ],
  "scaffoldState": {
    "status": "none",
    "summary": "",
    "miniExplanation": "",
    "example": ""
  },
  "roundHistory": [
    {
      "round": 1,
      "quote": "It proves the token is real.",
      "gapCategory": "[causal-gap]",
      "gapSummary": "The problem solved by the signature was not named.",
      "probe": "Why does the server need proof instead of trusting the token?",
      "scaffoldUsed": false
    }
  ],
  "sessionLogPath": "feynman-sessions/2026-04-30-jwt-signatures.md",
  "updatedAt": "2026-04-30T12:00:00-04:00"
}
```

### Session Log File

Created at Kickoff, updated every round, finalized at Exit.

**Default path**: `./feynman-sessions/YYYY-MM-DD-<concept-slug>.md`
**Override**: if the host environment has a configured output directory (e.g., `FEYNMAN_OUTPUT_DIR` or a user config), use that instead.

**Slug rules**: lowercase, kebab-case, non-alphanumeric → hyphen, collapse repeats. Example: "Attention Mechanism (Transformers)" → `attention-mechanism-transformers`.

**Collision**: if file exists, append `-2`, `-3`, etc.

### Session Log Template

```markdown
---
concept: "[Concept Name]"
status: in-progress  # in-progress | mastered | paused
rounds: 0
language: en  # en | ko | ja | ...
started: YYYY-MM-DDTHH:MM:SS
updated: YYYY-MM-DDTHH:MM:SS
---

# Feynman: [Concept Name]

## Round 1

**Explanation:**
> [user's words]

**Gap:** `[category-code]` [one-line description]

**Scaffold:** none

**Probe:** [the open-ended question or redirect that the AI sent back to close this round; preserves the dialog so the file alone reconstructs the session]

## Round 2

**Explanation:**
> [user's words]

**Gap:** `[category-code]` [one-line description]

**Scaffold:** none

**Probe:** [the open-ended question or redirect that the AI sent back to close this round]

---

## Refined Explanation

[One-paragraph clean version composed at exit, preserving user phrasings]

## Review Sheet

### Simple Explanation
[Plain-language version based on the final learner-owned explanation]

### Analogy
[One analogy]

### Analogy Limit
[Where the analogy breaks]

### Real Example
[One example]

### Transfer Quiz
1. [New application question]
2. [Why or how question]
3. [Boundary or edge-case question]

## Gap History

1. `[category-code]`: [summary]
2. `[category-code]`: [summary]

## Related Notes

- [Link 1](path/to/note.md) - [why relevant]
- [Link 2](path/to/note.md) - [why relevant]

## Next Concepts to Explore

- [concept 1] - [why next]
- [concept 2] - [why next]
```

### Status Transitions

- `in-progress`: session active or user paused without declaring finish
- `mastered`: AI detected 4/5 criteria AND user confirmed
- `paused`: user said "pause" / "later" without finishing

---

## Resume Detection (no-arg mode)

When user runs `/feynman` with no argument:

1. Glob session directory for `*.md` files
2. Read frontmatter, filter `status: in-progress`
3. Sort by `updated` timestamp, show top 1–3
4. Ask user: "Resume [X] or start new?"
5. On resume: read file, extract last round, continue from next round number

---

## List Mode Output

```
📋 Feynman Sessions

🟡 In Progress (2)
- 2026-04-05-attention-mechanism.md  (Round 3, 2 hours ago)
- 2026-03-29-tcp-handshake.md        (Round 2, 6 days ago)

✅ Mastered (5)
- 2026-04-01-jwt-signature.md
- 2026-03-28-event-loop.md
...

⏸️ Paused (1)
- 2026-03-15-raft-consensus.md
```

---

## Edge Cases

| Situation | Response |
|-----------|----------|
| First explanation is perfect | Don't end. Stress-test with an edge case or "what if X?" question (exploit `[edge-case-blind]` or `[boundary-blur]`) |
| User is stuck | Use the scaffold path: name the stuck point, give one mini ELI5 (60-100 words), give one concrete example, then require re-explanation. |
| Same gap repeated 2+ times | Trigger scaffold. The next learner answer is progress only; require a fresh-angle explanation or stress test before counting mastery. |
| User is hand-waving | Politely call it out: "Hold on — '[vague quote]' is fuzzy. What specifically does what here?" |
| User repeats previous answer | "That's almost the same as before. Try a slightly different angle" |

---

## Language Mirroring

**Default output language**: English.

**Mirror rule**: detect the primary language of the user's first explanation. Use that language for all subsequent AI turns. Record the detected language in the session log frontmatter (`language:` field).

If the user switches languages mid-session, stay with the original language unless they explicitly request a switch.

**Supported i18n layers**: see `i18n/` directory. Each language file provides:

- Translations of the 7 category codes
- Tone guidance (formal/casual, regional norms)
- Locally relatable analogies

---

## Tone Guidance (default: English)

- **Direct but warm**: "There's a gap here" not "you're wrong"
- **Specific, not vague**: quote the exact phrase, name the category, give a concrete nudge
- **One gap per turn, strictly**: cognitive load research shows batched feedback fails
- **No em-dash in output** (`—`); use en-dash, comma, or parentheses
- **Praise must be specific**: "good analogy" ❌ → "the phone-book analogy nails the indexing idea" ✅

See `i18n/en.md` for English tone patterns, `i18n/ko.md` for Korean (`~요체`), etc.

---

## Anti-Patterns (things to avoid)

- **Giving the answer**: Never. This skill's value is the user's struggle to articulate.
- **Multiple gaps per turn**: Batching diffuses focus.
- **Generic praise**: Use specific praise or skip it.
- **Accepting "I get it now" without proof**: Ask a fresh angle or stress-test.
- **Lecture-mode**: This is dialog, not explanation. Every AI turn ends in a question.
- **Scaffold too early**: do not give mini ELI5 before struggle or explicit request.
- **Counting copied scaffold as mastery**: scaffolded phrasing is not mastery evidence until the learner handles a fresh angle.
- **Primer as default**: `/feynman primer` is optional; `/feynman [concept]` remains learner-first.

---

## Further Reading

- `docs/gap-taxonomy.md` – full category definitions with 10+ examples each
- `docs/mastery-criteria.md` – detailed mastery criteria with edge cases
- `docs/design-rationale.md` – why this design, research grounding
- `examples/` – sample sessions across domains
- `i18n/` – language-specific tone and category translations