Teach Me With Analogies: The AI Prompt That Makes Hard Things Actually Click

A copy-paste prompt that turns any AI into a patient tutor — and doesn't let you off the hook until you actually understand.

Here's the trap almost everyone falls into with AI. You paste in something hard — a dense pull request, an unfamiliar part of a codebase, a concept from a field you don't work in — and you type "explain this to me." Back comes a tidy, confident wall of text. You read it, you nod, it all sounds reasonable… and a day later you couldn't explain a word of it to a colleague.

You didn't learn it. You recognized it. Those are very different things, and the gap between them is where a lot of wasted time lives.

There's a simple fix, and it's just a prompt. Instead of asking the AI to explain, you ask it to teach — the way a good tutor teaches: in plain analogies, checking your understanding at every step, and refusing to move on until you can say it back in your own words.

The exact prompt

This is the real thing — the exact message I pasted to kick off the session that became the companion post below. React on Rails is open source, so the pull request it points at is public. That means you don't have to take my word for any of this: paste the prompt below, unchanged, into your own AI assistant, and you'll get your own guided walkthrough of the very same design document.

Explain https://github.com/shakacode/react_on_rails/pull/4769 to me using only analogies and everyday examples. No jargon. Assume I have no background in this field.

After each analogy, check whether I've actually understood it by asking me one question. Based on my answer, go deeper or adjust the explanation.

Keep going until I can explain it back to you in my own words without using any technical terms.

That's the whole thing — three short instructions. Swap the GitHub link for anything you're trying to understand — a different pull request, a file, a whole concept — and everything else works unchanged. It looks almost too simple, but every clause is doing real work.

Why it works

Four small ingredients turn a passive explanation into actual learning:

"Using only analogies and everyday examples." An analogy forces the AI to map the hard idea onto something you already understand — a restaurant, a post office, a busy kitchen. To build that mapping, it has to identify what the idea actually does, not just what it's called. And because you already have intuition about the everyday thing, you can reason about the hard thing before you know any of its vocabulary.

"After each analogy… ask me one question." This is the ingredient people skip, and it's the most important one. Being asked a question forces active recall — you have to produce an answer, not just recognize a correct one. That's the moment your real understanding (or your gap) becomes visible, to the AI and to you. One question at a time keeps it a conversation instead of a quiz you skim.

"Based on my answer, go deeper or adjust." Now the explanation is personalized. If you nail the question, the AI moves on. If you're fuzzy, it re-explains that one piece a different way before piling on the next. You never get stranded, and you never sit through an explanation of something you already got.

"Keep going until I can explain it back… without any technical terms." This is the finish line, and it's a real test — the "teach it back" standard sometimes called the Feynman technique. If you can explain something in plain words, you understand it. If you can only parrot the jargon, you don't. Making that the exit condition means the session doesn't end when the AI is done talking; it ends when you can teach it.

Put together, these four moves quietly turn the AI from a lecturer into a tutor who actually watches whether you're keeping up.

What it looks like in practice

I used this exact prompt to understand a genuinely gnarly engineering design document — an architecture proposal about how web pages get streamed to your browser piece by piece. Going in, I had no intention of learning the internals. Coming out, I could explain the whole thing at a dinner table using nothing but a restaurant, a waiter, and a pushy busser.

Here's how it actually opened — the real first exchange, lightly trimmed:

Me: (the exact prompt above)

The assistant: "I'll start by reading the actual PR so my analogies map to what it really does." Then it began: picture a restaurant that brings out each dish the moment it's ready, and — for the slow main course — sets a little "your main course is on its way" card on the empty spot. Its question back to me: what is that card standing in for, and why not just leave the spot empty?

Me: "so i can start eating sooner and be happy"

The assistant: Confirmed that was the main point — then added the piece I'd glossed over: the card also saves the exact spot, so the real dish drops straight in when it's ready. On to the next analogy.

That rhythm — analogy, one question, my answer, a small correction, next analogy — kept going until I could explain the whole design in plain words. We wrote the full session up as a companion post:

→ Streaming a Web Page, Explained at a Restaurant Table

Read it not for the streaming details but for the rhythm — and remember the PR is public, so you can reproduce that exact session yourself with the prompt above.

How to reuse it for almost anything

The prompt is topic-agnostic. A few ways I reach for it:

• Onboarding to an unfamiliar codebase. "Explain what this service does using only analogies… assume I've never seen this system." You get a mental model before you get lost in the files.
• Decoding a scary pull request. Paste the PR link or description. Great for reviewing work in a part of the system you don't own.
• Briefing non-technical stakeholders. Run it yourself first, then hand the resulting analogies to the exec who asked "so what does this actually do?" You'll have a plain-English version ready.
• Learning outside your field entirely. Tax rules, a medical explanation, a contract clause, how a mortgage amortizes. The prompt doesn't care whether the topic is technical.

A couple of variations worth keeping in your back pocket:

• Swap the last line for "…until I can explain it back, then quiz me with three tricky edge cases" when you want to pressure-test your understanding, not just reach it.
• Add "Use the same running analogy the whole way through" when you want one coherent mental model instead of a fresh metaphor each step. (The restaurant piece above does exactly this.)

A few honest caveats

• It's a learning aid, not a source of truth. Analogies simplify by leaving things out, and AI can be confidently wrong. Once the concept clicks, verify the specifics against the real documentation, code, or an expert.
• Answer honestly. The whole mechanism depends on your real answers to the check-in questions. If you bluff "yep, got it," you're back to nodding at a wall of text.
• Let it be slow. The point is that it doesn't rush to the end. That back-and-forth is the feature, not overhead.

Why we care about this at ShakaCode

We build React on Rails, and a lot of what we do is help teams understand modern React rendering — server-side rendering, streaming, React Server Components — without drowning in jargon. Prompts like this one are part of how we work and how we explain our work. We even keep a growing set of AI-assistant quick-start prompts for getting productive with the framework fast.

Try the prompt on the next hard thing that lands in your lap. Then go read the restaurant version to see just how far a good analogy — and a well-timed question — can take you.