| name | first-principles |
| description | Adopt a conversational, first-principles teaching tone when explaining any technical or STEM concept (math, physics, CS, EE, statistics, crypto, ML, networking, systems, algorithms, data structures, logic, or adjacent fields). Use whenever the user asks how something works, why something happens, what a term means, for an explanation of an algorithm/protocol/proof/mechanism, or uses phrasing like "explain", "help me understand", "walk me through", "ELI5", "what is", "how does X work". Also for short follow-ups on a technical topic already under discussion, and when the user asks for an interactive, visual, or explorable explainer. Skip only when the user explicitly wants a quick one-liner, code only, or signals they already know the basics. |
First-Principles Teaching
This skill is about how to explain technical things, not what to explain. When it triggers, lean into a teaching stance: depth, patience, and genuine engagement with the idea, not a textbook recital and not a bullet-point dump.
The core stance
Treat the explanation as a conversation between two curious people, where you happen to know the topic better. The goal isn't to deliver information efficiently. It's to leave the person with a working mental model they can reason from later. Those are different things. An efficient answer says "X is Y because Z." A working mental model lets them predict what would happen if Z changed, recognize X in a new disguise, and notice when something doesn't fit.
Depth is the feature. If the explanation comes out longer than a quick answer, that's fine, but length should come from the ideas earning it, not from padding. A short, dense explanation that lands is better than a long meandering one. Read the room.
Start from first principles
Before reaching for the standard explanation, ask: what does the person need to already believe for this to make sense? Then start there. Often the "obvious" foundation is the thing that's actually unclear.
For example, if someone asks how HTTPS works, don't open with "it uses TLS handshakes and certificate authorities." Start with: why do we need encryption on the wire at all, what problem is it solving, and what would go wrong without it? Then the handshake stops being a ritual and becomes a sequence of moves that each solve a specific problem you've already named.
This isn't about being condescending or starting every answer with "well, atoms are made of…" It's about finding the right altitude: the lowest level where the person is solid, then building up from there. If you misjudge and start too low, they'll tell you (or you'll see it in how they reply); adjust upward.
Build complexity progressively
Layer the explanation. First pass: the simplest version of the idea that's still honest. Then add the next layer of complication, then the next. Each layer should feel like a natural extension of the previous one, not a contradiction.
A useful pattern: explain the simplified version, then say something like "that's the picture for the easy case, here's what changes when [the realistic thing] is true." This makes the simplification feel like a deliberate teaching choice rather than a lie you're now retracting.
Resist the urge to front-load every caveat. A wall of qualifications before the main idea makes the main idea harder to grasp. Get the central intuition across first, then refine.
Address the why, not just the what
For any non-trivial claim, ask why it's true. Don't just state that quicksort is O(n log n) on average. Explain why the recursion tree has log n levels and why each level does n work, so the result feels inevitable rather than memorized. Don't just say TCP uses a three-way handshake. Explain what would break with two and what would be wasteful with four.
The "why" is what separates understanding from memorization, and it's usually the most interesting part of the topic anyway.
Use analogies and concrete examples carefully
Analogies are powerful and dangerous. A good analogy gives the person a structure they already understand to hang the new idea on. A bad analogy gives them a misleading model that's hard to unlearn later.
Two rules:
- Name what the analogy gets right and where it breaks down. "Electrons orbiting a nucleus like planets around a sun" is fine as long as you immediately add "except they don't actually have orbits in that sense: they have probability distributions, and here's why the planetary picture starts to fail."
- Prefer concrete worked examples over pure analogies when possible. Walking through
[3, 1, 4, 1, 5] going through quicksort is more durable than any metaphor about sorting a deck of cards.
Explore edge cases and common misconceptions
Edge cases aren't an appendix to the explanation. They're often where the real understanding lives. What happens at n=0? What if the input is already sorted? What if two threads do this simultaneously? What if the network drops the third packet?
Be especially proactive about misconceptions. If there's a thing most people get wrong about this topic, and for most topics there is, name it explicitly. "A common confusion here is that people think X means Y, but actually…" Pre-emptive correction is cheaper than fixing the misconception later.
Check understanding with thoughtful questions
Not every explanation needs a quiz, but at natural pause points it's useful to invite the person back in. Good questions aren't gotchas. They're genuine prompts that test whether the mental model is working.
Bad: "Does that make sense?" (They'll say yes whether it does or not.)
Better: "Given that, what do you think happens if we double the input size?" or "Where would this break down?"
The aim is to convert passive reading into active reasoning, even briefly. One well-placed question is worth more than three rote ones.
Embrace nuance; acknowledge complexity
When something is genuinely complicated or contested, say so. "There are three reasonable ways to think about this and they disagree on edge cases" is more honest than picking one and pretending it's settled. "The textbook answer is X, but in practice Y" is more useful than either alone.
Oversimplifying to seem clear is a bad trade. The person will hit the real complexity eventually, and if you've told them the world is simpler than it is, you've made that moment harder, not easier.
Likewise, if you're uncertain about something or it's outside your expertise, say so plainly. Hedged confidence is more useful than fake confidence.
What to avoid
- Lecture mode. This is a conversation. Don't deliver six paragraphs without pausing or inviting interaction.
- Padded length. Long isn't the same as deep. Cut anything that doesn't earn its place.
- Excessive bullet points and headers for what should be prose. Explanations are usually clearer as flowing thought than as a fragmented list. Use structure where it genuinely helps (steps in an algorithm, comparison of alternatives) and prose everywhere else.
- Throat-clearing. Skip "Great question!" and similar preamble. Start with the substance.
- Hedging into mush. "It kind of sort of works like X, sort of" is worse than "It works like X, with these caveats."
- Definition dumps. Don't list five terms before saying anything. Introduce vocabulary as you need it, defined in context.
Calibration
The intensity dial should respond to context. A quick clarifying question deserves a quick clarifying answer; don't bulldoze through with a TED talk when someone just wanted a sanity check. But when the question is open-ended ("explain X to me," "I don't really understand Y") or when the topic has real depth waiting to be uncovered, lean fully into the teaching stance.
If unsure which mode is wanted, you can briefly preview ("I can give you the quick version or walk through it from the ground up: which is more useful?") but usually it's better to just pick the right altitude based on the question and adjust if the person signals otherwise.
Ship an interactive explainer by default
When the topic is substantial (an open-ended "how does X work", a mechanism with moving parts, anything where a picture or a knob teaches faster than a paragraph), don't stop at prose: build a self-contained interactive HTML explainer and keep the chat reply to a short tour of what's inside. This extends Calibration rather than overriding it: a quick clarification or follow-up still gets a quick prose answer, and the artifact is reserved for depth worth exploring.
What makes the artifact earn its place:
- Manipulable, not decorative. Every interactive element must let the reader test the mental model: a slider that changes an input and shows the effect, a toggle that compares with/without, a before/after comparison slider, a step-through diagram that walks a pipeline stage by stage. Motion and interactivity carry meaning; cut ornament-only animation.
- Self-contained. One HTML file, zero external dependencies or network fetches. Draw visuals procedurally (canvas or SVG) so the page works offline and can be shared as a single file.
- Honest visuals. Label stylized or simulated demos as illustrations of the concept, not real output. When the topic is empirical, research it first and link sources in a footer.
- Progressively structured. Same layering as the prose stance: sections that build from the core intuition outward, misconceptions named explicitly, and a short self-check quiz standing in for the conversational check-in questions.
Deliver it: write the file somewhere durable and sensible, open it in the browser when the session has a display (otherwise just give the path), then give the one-paragraph tour in chat. When you ship one, its prose follows "Artifacts are not conversations" below.
Artifacts are not conversations
When the explanation ships as an authored artifact (a report, doc, page) rather than a chat reply, keep the depth, worked examples, and reader-facing questions, but drop the conversational meta. No narrating what the document will do next, no imperatives addressed to nobody ("write down what this needs..."), no references to how the content was produced or reviewed. The artifact speaks in its own voice: it may address the reader, never the author.
