The Feynman Technique and Learning Notes

Build the mental model

1. Learn a concept

Learn a concept the normal way.

2. Explain simply

Explain it as if to a shopkeeper uncle with no background in the topic.

3. Find the gaps

Mark any term you cannot define or step you cannot justify.

4. Review the source

Re-read only the part that covers the gap, not the whole chapter.

5. Explain again

Restart the explanation from the beginning, including the fixed part.

"Explain simply" has a real test: calling an API "an interface for programmatic access" just restates jargon in different jargon — it has not actually explained anything.

The fixed note format — Topic, What is it, Why does it matter, How does it work, Example, Common mistake, Question, Practice, Related topic — is the exact same shape every lesson on this site already follows.

text

FEYNMAN TECHNIQUE LOOP
----------------------
FEYNMAN TECHNIQUE LOOP
-----------------------
[learn concept] -> [explain simply] -> [find the gaps]
        ^                                     |
        |                                     v
        +------ [explain again] <-- [review source]

Connect it to a real scenario

Pick a concept and set a five-minute timer — explain it with notes closed, imagining a specific person with no background listening.

Mark the exact spot where you hesitate — do not push through it
Re-read only the part that covers the gap, not the whole chapter
Once fixed, restart the explanation from the beginning

Write the note in the fixed format (Topic / What is it / Why it matters / How it works / Example / Common mistake / Question / Practice / Related topic) — fill Common mistake with the gap you actually found.

Explaining simply means the shopkeeper-uncle test, not restating jargon with different jargon
Finding the gap is the actual learning event, not a formality
Every lesson on this site already follows this exact Feynman-style note format

Try the working example

javascript

// Toy heuristic, not real NLP: flags jargon used without a nearby plain-language cue.
function findExplanationGaps(explanation, jargonTerms, windowChars = 60) {
  const lower = explanation.toLowerCase();
  const plainCueMarkers = ["means", "in other words", "i.e.", "that is", "which is", "is a ", "is the ", "(", "or simply"];
  const gaps = [];

  for (const term of jargonTerms) {
    const termLower = term.toLowerCase();
    let idx = lower.indexOf(termLower);
    if (idx === -1) continue;

    const windowStart = Math.max(0, idx - windowChars);
    const windowEnd = Math.min(lower.length, idx + term.length + windowChars);
    const nearby = lower.slice(windowStart, windowEnd);

    const hasCue = plainCueMarkers.some((marker) => nearby.includes(marker));
    if (!hasCue) gaps.push(term);
  }

  return gaps;
}

const jargon = ["embedding", "tokenization", "gradient descent", "overfitting"];

const explanationA =
  "An embedding is a list of numbers that represents meaning, so similar " +
  "words end up with similar numbers. Tokenization is the step that splits " +
  "text into small pieces the model can read. Gradient descent is the process " +
  "that nudges the model's numbers downhill toward fewer mistakes.";

const explanationB =
  "The model uses embedding and tokenization before gradient descent " +
  "kicks in, and overfitting can happen if you are not careful.";

console.log("Explanation A gaps:", findExplanationGaps(explanationA, jargon));
console.log("Explanation B gaps:", findExplanationGaps(explanationB, jargon));

You should see

Explanation A gaps: []
Explanation B gaps: [ 'embedding', 'tokenization', 'gradient descent', 'overfitting' ]

Explanation A defines each term in plain language right next to it, so no gap is found. Explanation B uses all four terms without defining any of them, so all four get flagged as gaps. (This is a toy heuristic, not a real NLP tool.)

5-minute try-it

Write an explanation for a concept you think you understand, list four or five technical terms in it, and run findExplanationGaps(). For every flagged term, add a plain-language definition and run it again.

One important caution

Restating jargon with different jargon and assuming that counts as an explanation

Re-reading the entire chapter after finding a gap instead of just the specific part

Wikipedia: Metacognition — Productivity Systems