# AI Corrected Feynman

> Run the AI-corrected Feynman technique on a concept — the user explains it in their own words, Claude finds real errors/vague spots/unsupported causal claims (not encouragement), scored 1-10, repeated until it scores 10 — then logs every round into the concept's own note. Supports a chain mode that walks an ordered, categorized list of related concepts one at a time, and a review mode that schedules spaced repetition (SM-2) on already-passed concepts. Use when the user wants to "用AI纠错费曼学习法学一下 X", "费曼一下 X", practice explaining a concept for AI correction, work through a "学习链"/concept chain step by step, asks what's due for review / wants to review passed concepts, or asks to log/continue such a session.

- Skill: `goodluckz/ai-corrected-feynman` (Agent Skill)
- Install (CLI): `npx skillmds@latest add goodluckz/ai-corrected-feynman`
- Raw SKILL.md: https://api.skillmd.com/api/skills/goodluckz/ai-corrected-feynman/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: goodluckz (https://skillmd.com/u/goodluckz)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/goodluckz/ai-corrected-feynman

---


# AI-Corrected Feynman Technique

Implements [[AI纠错费曼学习法]] (`/Users/zhaoliang/LocalDocuments/vaults/vault/pages/AI纠错费曼学习法.md`):
the classic Feynman step 4 ("teach it to someone") needs a real listener willing to push back.
Claude plays that listener — the user explains, Claude corrects, repeat until nothing's left to find.

## Non-negotiable ground rules

- **Never explain the concept first.** If Claude explains before the user does, the whole point —
  forcing the user to expose what they don't actually understand — is defeated. If asked to "explain
  X" in a context that matches this skill, prompt the user for their own explanation instead.
- **Don't just praise.** Every round needs a real critique pass: factual errors, hand-wavy/vague
  spots papered over with jargon, causal claims that don't actually hold up. If a round is genuinely
  correct and complete, say so plainly — but check for real gaps first, including subtle ones (wrong
  category/analogy, mechanism described as its effect, edge cases not covered).
- **Watch for parroting.** If a re-explanation is suspiciously close to Claude's own prior correction
  wording, that's not evidence of understanding — say so and ask for it in the user's own words/own
  example, don't score it as a real pass.
- **Ground corrections in verifiable facts** when available — prior conversation context, docs, code
  actually read/run — not just Claude's prior knowledge. A correction backed by "we tested this
  earlier and it took 6s, not ~0s" lands harder than a bare assertion.
- **Score every round, 1-10, with a one-line reason.** The score should track structural
  understanding (does the mental model hold up) more than completeness of wording.
- Continue rounds until either the user says to stop, or a round earns 10/10 with nothing left to
  correct — mark that round's conclusion as `**结论：通过**`.

## Flow (single concept — first-time learning)

1. **Identify the concept and where the log should live.** If the concept already has a note in the
   current vault (e.g. `pages/<Concept>.md`), log there. If not, ask where it should go — don't
   assume a new file location. Default assumption (unless the user says otherwise): log gets written
   into the concept's own page under a `## 费曼纠错记录` section, not a separate log file.
2. Ask the user to explain the concept in plain language, without looking up material. Wait for their
   answer — do not proceed on their behalf.
3. Critique it per the ground rules above. Give the 1-10 score with a reason.
4. Ask whether to log this round now or wait, then append it to the concept page using the template
   below (see [Log template](#log-template)) — never overwrite prior rounds, only append.
5. If not yet correct, ask the user to revise and re-explain (informed by the critique) and repeat
   from step 3, incrementing the round number.
6. On the final passing round, add `**结论：通过**` after that round's score line, then **initialize
   spaced-repetition scheduling** for this concept (see [Review mode](#review-mode-sm-2-spaced-repetition)),
   since a first pass is itself the first SM-2 repetition.

## Log template

Append this section to the concept's page if it doesn't already have one:

```markdown
## 费曼纠错记录

参见 [[AI纠错费曼学习法]]。自己先讲、AI 纠错、修正重讲，直到讲对为止——每轮都保留，不覆盖前一轮，方便看到理解是怎么一步步修正的。
```

Then for each round, append (never edit/overwrite earlier rounds):

```markdown
### 第 N 轮 — YYYY-MM-DD

**我的解释：**
<用户原话，逐字或整理后的转述都行，不要替用户改写立场>

**AI 纠错：**
- <具体错误/含糊点/站不住的因果关系，没有就写"无——这句复述准确">

**理解度评分：** X/10 — <一句话理由>
```

On the concluding round, add directly under that round's score line:

```markdown
**结论：通过**
```

## Chain mode (learning chain)

Use when the user wants to work through a set of related concepts in order — e.g. "把这些概念做成学习链一步步学"、"继续那条学习链" — rather than just one concept in isolation. Chain mode is the single-concept flow above, run repeatedly over an ordered list, with progress tracked in a dedicated chain note so it survives across sessions.

### Building a chain

1. If the user hasn't already given (or previously agreed to) an ordered, categorized concept list,
   help them build one: group concepts into stages by dependency (foundational concepts a later
   concept's explanation would otherwise have to re-derive come first), not just topic similarity.
2. Write the chain to its own note: `pages/<链名> 学习链.md`. One `##` section per category, each
   concept as an unchecked checklist item linking to its own page:

```markdown
---
aliases: []
created: YYYY/MM/DD
tags:
  - ai
  - learning-chain
title: <链名> 学习链
---

# <链名> 学习链

<一两句话说明这条链是什么、覆盖范围来自哪里>

## <分类1>

- [ ] [[概念A]]
- [ ] [[概念B]]

## <分类2>

- [ ] [[概念C]]
```

3. Don't duplicate per-round Feynman content into the chain note — it stays a thin index. The actual
   record of understanding lives on each concept's own page under `## 费曼纠错记录`, per the single-
   concept flow above.

### Running a chain

1. **Find the resume point.** Read the chain note top to bottom; the next concept to work on is the
   first unchecked `- [ ]` item. (Checkbox state is the source of truth for "where we are" — if it's
   ever out of sync with a concept page's own `**结论：通过**`, trust the concept page and fix the
   checkbox.)
2. **Run that concept through the single-concept flow** (steps 2–6 above), same ground rules — no
   shortcuts because it's part of a chain.
3. **On that concept's pass**, edit the chain note: flip its checkbox to `- [x]`. Then ask whether to
   continue immediately to the next concept or stop here for today.
4. **On stop**, leave the chain note as-is (the flipped checkbox is already the correct resume
   marker) — no other bookkeeping needed. A later "继续那条学习链" just re-enters at step 1.
5. Don't jump ahead to a later concept while an earlier one in the chain is still unchecked, unless
   the user explicitly asks to skip it — the ordering encodes a dependency, not just a preference.

## Review mode (SM-2 spaced repetition)

Passing a concept once doesn't mean it's retained. Review mode schedules and runs spaced repetition
on concepts that already have `**结论：通过**`, using the classic SM-2 algorithm (Wozniak), tracked
directly in each concept page's frontmatter — no external app needed.

### Frontmatter fields (per concept page)

```yaml
review_due: YYYY-MM-DD     # next date this concept is due for review
review_interval: N          # current interval in days
review_ease: N               # ease factor × 100, e.g. 250 = EF 2.50 (SM-2 default start)
review_reps: N               # consecutive successful repetitions (resets to 0 on a failed review)
```

### Initializing on first pass

The moment a concept earns `**结论：通过**` for the first time, this *is* SM-2's first repetition.
Set: `review_reps: 1`, `review_interval: 1`, `review_due` = tomorrow's date, and `review_ease` from
the quality of that final passing round (map the 1-10 Feynman score to SM-2 quality 0-5, roughly
`quality = round(score / 2)`), via the EF update formula below with a starting EF of 2.50.

After writing the frontmatter, also **create the SP task** for this concept — see
[SP sync](#sp-sync-cross-vault-review-inbox).

### SM-2 update formula

On every review (first pass included), given quality `q` (0-5) and prior `EF` (default 2.50 if none):

```
EF' = EF + (0.1 - (5 - q) * (0.08 + (5 - q) * 0.02))
EF' = max(EF', 1.3)

if q < 3:
    review_reps = 0
    review_interval = 1
else:
    review_reps += 1
    if review_reps == 1: review_interval = 1
    elif review_reps == 2: review_interval = 6
    else: review_interval = round(review_interval * EF')

review_ease = round(EF' * 100)
review_due = today + review_interval days
```

A `q < 3` result resets the repetition streak — treat it as evidence the understanding didn't
actually stick, not just a bad day.

### Running a review session

Trigger on things like "今天有什么要复习的"、"开始复习"、"review".

1. **Find due concepts.** Prefer `sp_get_tasks` filtered on `project: "费曼复习"` (and `filter: "today"`
   or `"all"` as appropriate) — it already aggregates due concepts across every vault, so this is
   normally faster than scanning each vault's `pages/*.md` for `review_due <= today`. Fall back to
   scanning pages directly if SP is unavailable, a vault's concepts aren't synced yet, or the user
   scopes the request to one vault/chain by name.
2. **Per due concept, run a short recall check** — lighter than first-time learning: ask for a quick
   explanation (a few sentences, not a full teach-back), same anti-parroting and real-critique rules
   apply. This is not a fresh multi-round drill by default; it's "can you still produce this on
   demand right now."
3. **Judge quality 0-5** from how the recall went:
   - 5 — correct, fluent, no hesitation, nothing to correct
   - 4 — correct with a minor imprecision, self-caught or trivially fixed
   - 3 — correct after one real clarifying correction
   - 2 — recalled the shape but got a real mechanism wrong; needed real correction (reps reset)
   - 0-1 — couldn't reconstruct the core mechanism at all (reps reset)
4. **Apply the SM-2 update** above and write the new `review_due`/`review_interval`/`review_ease`/
   `review_reps` into that concept's frontmatter. Then **reschedule the SP task** to the new
   `review_due` — see [SP sync](#sp-sync-cross-vault-review-inbox).
5. **If quality < 3**, don't stop at the quick check — the gap is real, so run that concept through
   a full correction round appended to its `## 费曼纠错记录` (same as first-time learning steps 3-5),
   not just a frontmatter update, since the understanding needs actual repair, not just rescheduling.
6. **Log the review outcome** on the concept page under a `## 复习记录` section (separate from
   `## 费曼纠错记录`, which stays for the original learning rounds):

```markdown
## 复习记录

| 日期 | 质量(0-5) | 结果 | 新间隔 |
|------|-----------|------|--------|
| YYYY-MM-DD | q | 通过 / 需要重新纠错（见费曼纠错记录第N轮） | N天 |
```

Append one row per review, oldest first — never overwrite prior rows.

### SP sync (cross-vault review inbox)

Concept pages live scattered across vaults (AI-vault, survey-vault, etc.), so `review_due` alone
can't be scanned in one place. SP (Super Productivity, via the `sp-mcp` tools) is that one place —
a task per concept, all filed under a single shared project so the SP planner view is a cross-vault
review inbox. SP frontmatter in each concept page stays the source of truth for SM-2 state
(`review_ease`/`review_reps`/`review_interval`); the SP task is just a scheduling pointer to it.

- **Project:** `费曼复习`, shared across all vaults — do not create a per-vault project.
- **Tag:** `费曼复习` (via `sp_create_tag` if `sp_get_tags` doesn't list it yet).
- **Title:** `复习: <概念名>` (the concept's page title / filename without extension).
- **`dueDay`:** the concept's current `review_due`.
- **`notes`:** the concept page's path relative to its vault, prefixed with the vault name, e.g.
  `AI-vault/pages/Tokenizer.md` — this is what lets a review session jump back to the right file.

**Creating** (on first pass — see [Initializing on first pass](#initializing-on-first-pass)): call
`sp_create_task` with the fields above.

**Rescheduling** (on every later review — see [Running a review session](#running-a-review-session)):
call `sp_update_task` or `sp_schedule_task` with `task: "复习: <概念名>"` and the new `dueDay`. If the
title match is ambiguous (SP returns multiple candidates — this can happen if the same concept name
exists in more than one vault), disambiguate using each candidate's `notes` path against the concept
page you're actually updating, then retry with the resolved task id.

If SP isn't running (`sp-mcp` tools error out), don't block the Feynman/review flow on it — finish
the frontmatter update, tell the user the SP sync failed, and move on; do not silently skip mentioning
it.

## Reference example

`/Users/zhaoliang/LocalDocuments/vaults/survey-vault/pages/dlt.md`'s `## 费曼纠错记录` section is a
worked example — 4 rounds on dlt (6/10 → 8/10 → 9/10 → 10/10 通过), including a correction that was
verified against a benchmark run earlier in that conversation rather than asserted from memory alone.