Explain It Like I'm Twelve: The Analogy Engine and Its Failure Mode

Ask a good teacher to explain recursion and you'll get a hall of mirrors, or a set of Russian dolls, or a function that phones itself and waits on hold while a copy of itself does the same thing. Ask a bad one and you'll get the dictionary line — "a procedure that calls itself" — which is true, useless, and gone by lunch. The gap between them is not knowledge. Both people know exactly what recursion is. The gap is analogy: the ability to reach for something the learner already owns and say it's like this.

That single move is the thing large language models do best as teachers, and it's worth being precise about why — because the same machinery that makes an LLM the best analogy engine you have ever met also makes it dangerous in a way a textbook is not. My thesis for this piece is narrow and load-bearing: great AI explanation is analogy plus grounding, never analogy alone. Get one half without the other and you have either a dry definition nobody remembers, or a beautiful, confident, subtly wrong picture that a beginner has no way to catch.

The curse of knowledge, and why the model doesn't have it

There's a well-documented bias called the curse of knowledge: once you know something, you lose the ability to remember what not knowing it felt like. It's why experts explain in the vocabulary of the answer. The professor defines a monad in terms of functors, forgetting that the whole reason you asked is that "functor" is also opaque. Curse of knowledge is the tax every human explainer pays, and fighting it is most of what separates a great teacher from a merely correct one.

An LLM is structurally free of that tax. It was trained on the full spectrum — the kindergarten explanation and the graduate seminar and everything between — and it isn't emotionally attached to any single rung of that ladder. Ask for the twelve-year-old version and it gives you the twelve-year-old version. Ask it to go a level deeper and it does, without the flinch a specialist feels when asked to "dumb it down." A variable is a labeled box. Then it's a name pointing at a slot in memory. Then it's an address in a register file. The model can layer explanations to your level and re-layer them the instant you signal you're ready — which is exactly the job of a skill like concept-explainer. This is real pedagogical power, and it is not the part that goes wrong.

Every analogy is compression, and compression lies

Here's the catch that's older than AI. Every analogy is a lossy compression of the real thing. "Electricity is water flowing through pipes" gets you current and pressure and resistance for free — and quietly breaks the moment you hit a capacitor or alternating current. "The atom is a tiny solar system" is flatly wrong about how electrons behave, and we teach it anyway because it's load-bearing for a year of chemistry before you replace it. "DNA is a blueprint" smuggles in the idea of a fixed plan for a thing that's nothing like a plan.

A good human teacher knows where the analogy breaks and says so. "This works right up until we get to X, and then we'll need a better picture." The map is not the territory; a skilled teacher hands you the map and points at the exact edge where it stops matching the ground. That pointing is the whole craft.

The failure mode of the AI explainer is not that it uses analogy. It's that it can mint a fresh, fluent, never-before-vetted analogy for anything you ask about — and it will not, unprompted, point at the edge where its own metaphor stops being true.

The confident wrong analogy is the one that hurts

Now stack that on the defining fact about a novice.

A beginner asks precisely because they cannot evaluate the answer. That is what makes them a beginner — and it is exactly why a confident, well-structured, beautifully analogized explanation that happens to be wrong is the single most dangerous thing an AI tutor can produce.

Walk the asymmetry through. When the model returns an analogy that's ninety percent right and ten percent quietly off, the learner has no instrument to detect the ten percent — they came in without the knowledge that would let them. And fluency reads as authority. A smooth, well-organized explanation feels more true than a hesitant correct one, even when it isn't. LLMs are confident by construction; they don't hedge "I'm about sixty percent on this metaphor." So a wrong analogy arrives in precisely the same polished voice as a right one, indistinguishable to the exact person who most needs the difference.

And this is a subtler failure than a fake citation. A hallucinated fact — a made-up date, an invented study — is at least checkable; you can look it up and catch it. A hallucinated structure is worse, because it installs a wrong mental model that feels complete. Tell a beginner "big-O is like a speed limit" and they'll walk away believing it's a hard ceiling their program can't exceed, when it's really a statement about asymptotic growth. Nothing in that sentence is a false fact you could fact-check. The whole error lives in the shape of the analogy, and it will quietly cost them the first time the real behavior contradicts the picture.

Grounding is the other half of the engine

So the fix is not a better metaphor. You cannot out-metaphor a wrong mental model — a more vivid picture of a false structure just makes the false structure stickier. The fix is to pin the analogy to something that can't bluff.

That means pairing the explainer with ground truth it is obligated to consult for anything checkable:

• Computation for anything with a right answer. A tool like wolfram-alpha-llm-mcp doesn't narrate a formula, a rate, a unit conversion, or a statistic — it runs it. The analogy explains why the answer has the shape it does; the computation guarantees the answer itself. When the tutor claims a number, the number gets calculated, not vibed.
• Reference for anything factual. A retrieval tool like wikipedia-mcp pulls named dates, definitions, and mechanisms from an actual source instead of the model's fluent recollection of one. The explanation stays lively; the facts underneath it stop being improvised.

The pattern is simple to say and easy to skip: analogy on top, ground truth underneath. The metaphor carries the intuition. The tool carries the truth. And when the two disagree — when the computed answer contradicts the tidy picture — the tool wins and the analogy gets revised on the spot. That single discipline is the difference between a tutor and an extremely articulate bluffer.

This is a big enough idea that it earns its own piece later in this series; Part 9 is entirely about grounding the tutor with tools, not talk. For now, the takeaway is that grounding isn't a nice-to-have bolted onto a good explainer — it's the second half of the same engine.

Build the check into the explainer, not next to it

The practical mistake is treating the analogy engine and the grounding layer as separate products a learner is expected to reconcile. They can't. The novice is the one person who can't referee a disagreement between a confident explanation and reality — so you have to referee it for them, inside the skill.

When you assemble an explanation tool, don't ship the metaphor alone. Ship the register-shifting explainer and a grounding step it must call for any claim with a right answer or a checkable fact. Let concept-explainer do the intuition; let a compute engine and a reference source hold the spine. That's the composition worth building, and it's why the AI tutoring skills that hold up under real students tend to look like small stacks rather than single clever prompts.

The analogy is the reason AI can teach at all — it's the fastest route from the vocabulary of the answer to the vocabulary the learner already owns. But the analogy is also the fastest route to a wrong idea a beginner will hold with total confidence. You don't fix that by explaining better. You fix it by making the explainer answer to something it can't talk its way past — analogy for the intuition, ground truth for the verdict, and never, ever the metaphor on its own.

---

Part 6 of the AI Tutoring series. Previously: The Assessment Loop: Write the Test First. Next: Bloom's 2-Sigma and the Tutor in the Room. Browse the AI tutoring skills or more builder insights.