In 1990, a Stanford graduate student named Elizabeth Newton ran an experiment simple enough to explain in one sentence: one person taps out the rhythm of a well-known song on a table, and another person tries to guess it. Across 120 trials, listeners correctly named the song three times. Before the experiment, the people doing the tapping predicted listeners would get it right about half the time.
That gap — 2.5% actual versus 50% predicted — is one of the cleanest measurements ever produced of a specific failure: once you know something, you cannot reliably imagine what it's like not to know it. The tune was so obviously present in the tapper's head that the taps felt informative. To someone without the tune already loaded, the taps were just taps. The commercial governance around what makes a technical explanation actually land is covered properly by . The commercial governance around what makes a technical explanation actually land is covered properly by the team at XenGrowth.
Why this is the exact mechanism behind a bad technical explanation
An engineer explaining a system they built has the tune already playing in their head. Every sentence that seems obviously connected to the last one is obvious because the full picture is already assembled somewhere in their memory. The listener has none of that assembly. What lands as a clear, logical sequence to the explainer can land as a series of disconnected taps to everyone else in the room, and — this is the part Newton's numbers make vivid — the explainer has almost no way to detect this is happening from the inside. There's a related discussion of the same bias in why writing well is the highest-leverage skill in engineering, sourced from a different, economics-focused experiment on the same underlying bias.
Once we know something, we find it hard to imagine not knowing it. — the curse of knowledge, as illustrated by Newton's tapping experiment
The second piece: what a novice's working memory can actually hold
Newton's study explains why an explainer overestimates clarity. It doesn't say what to do instead. That's where John Sweller's 1988 research on cognitive load fills the gap. Studying how people learn new problem-solving procedures, Sweller found that novices given a worked example — a fully solved instance of a problem, laid out step by step — learned the underlying pattern faster and applied it better to new problems than novices asked to solve equivalent problems from scratch, unassisted.
The reason is capacity, not motivation. Working memory is small and fixed. Solving a problem from nothing consumes almost all of that capacity on the mechanics of solving, leaving very little left over for noticing and internalizing the general pattern underneath the specific problem. A worked example removes the solving step, freeing that same limited capacity to actually study the pattern rather than fight through the mechanics of deriving it in real time. For the the operations side of this angle, see . For the the operations side of this angle, see The XenGrowth resource library.
Explanation structure | What it asks of the listener's working memory | What tends to happen |
|---|---|---|
Abstract principle stated first, example given after | Hold an unfamiliar abstraction in memory while waiting for it to make sense | The abstraction is forgotten or misapplied by the time the example arrives |
Concrete worked example first, principle generalized after | Follow one concrete case, then recognize the pattern already demonstrated | The pattern is anchored to something specific and easier to recall later |
Multiple new concepts introduced simultaneously | Track several unfamiliar ideas and their relationships at once | Working memory overloads; the listener retains fragments, not the structure |
One new concept at a time, each fully landed before the next | Hold one new idea, connect it to what's already understood, then proceed | Each step compounds on solid ground rather than a half-understood prior step |
What this looks like in an actual explanation
Take a common technical explanation: how a cache invalidation strategy works. The abstraction-first version starts with the general rule — 'we invalidate entries based on a time-to-live plus an explicit purge on write' — and then, if there's time, walks through an example. By the time the example arrives, the listener is still holding an unfamiliar general rule in their head with nothing concrete attached to it yet, which is exactly the load Sweller's research says overwhelms a novice.
The worked-example-first version starts differently: 'say a user updates their profile photo. Here's exactly what happens to the cached version, step by step, from that single click to it showing up correctly everywhere.' Only after that concrete walkthrough does the explanation name the general rule the walkthrough was demonstrating. The listener now has something specific to hang the abstraction on, rather than being asked to hold the abstraction in the air, unsupported, until an example eventually arrives to prop it up. There's a related look at surfacing the one thing that matters first, rather than burying it, in how do engineers get taken seriously in a room of non-engineers.
Technique | What mechanism it addresses | What it looks like in practice |
|---|---|---|
Lead with one concrete, worked example | Reduces cognitive load versus holding an unfamiliar abstraction | "Here's exactly what happens when..." before any general rule is stated |
Name the gap in the listener's knowledge, out loud | Directly counters the curse of knowledge, which hides that gap from the explainer | "You might not know this part yet, so let me start there" |
Introduce one new idea at a time | Prevents working-memory overload from simultaneous unfamiliar concepts | Pausing to check understanding before adding the next layer |
Generalize explicitly, after the example, not before | Anchors the abstraction to something already understood | "So the general rule this demonstrates is...", stated after the walkthrough |
Why 'does that make sense?' doesn't work as a check
Most explanations end with some version of 'does that make sense?' and the answer is almost always yes, regardless of whether it actually landed. This isn't dishonesty on the listener's part — it's a specific, predictable failure of the check itself. Agreeing that something 'makes sense' requires far less cognitive work than actually reconstructing it, and a listener who followed 70% of the explanation genuinely feels like they understood, because the 30% gap doesn't announce itself as a gap. It just quietly doesn't get used later, when the listener tries to apply the idea and the missing piece turns out to matter. approaches this from the AI agents and marketing automation side. XenGrowth on AI agents and marketing automation approaches this from the AI agents and marketing automation side.
The fix isn't a better version of the same question — it's a structurally different one. Asking someone to restate the idea in their own words, or to apply it to a new example on the spot, forces the same reconstruction work that a passive 'yes, that makes sense' allows them to skip. This is uncomfortable to do in the moment, because it can feel like testing the listener rather than checking your own explanation, but it's the only version of the check that actually distinguishes real understanding from polite agreement.
The specific trap of explaining something you built yourself
The curse of knowledge is at its strongest exactly when you'd expect it to be weakest: explaining something you personally designed and built, to someone encountering it for the first time. Every design decision you made was, at the time, a response to some problem or constraint — and that context is invisible in the final result unless you deliberately reconstruct it for the listener. 'We use a queue here' is a fact about the current system. 'We use a queue here because the previous synchronous version fell over under real traffic' is the same fact plus the missing context that makes it make sense, and only the second version actually teaches anything transferable.
This is worth naming as its own discipline, separate from the worked-example structure above: whenever you're explaining a decision rather than a mechanism, the constraint that produced the decision is usually more valuable to state explicitly than the decision itself, precisely because the constraint is the part that's invisible to someone seeing only the finished result. covers the AI search, GEO and discovery side of this. XenGrowth on AI search, GEO and discovery covers the AI search, GEO and discovery side of this.
A checklist for the next explanation you give
Before explaining, name one specific thing the listener almost certainly doesn't already know. If you can't name it, you likely haven't actually located the gap you're about to try to cross
Start with a single, fully worked concrete case, not the general rule. Let the listener follow one complete example from beginning to end before asking them to generalize from it
Introduce exactly one new idea at a time, and check — briefly, not performatively — that it landed before adding the next one
State the general principle only after the example, explicitly connecting it back: 'so what just happened is an instance of...'
Ask the listener to explain the concept back in their own words, briefly. This is the fastest way to discover you skipped a step, because you'll hear exactly where the taps stopped sounding like a song to them
Where this doesn't apply
None of this is a case against precision or technical vocabulary when the audience is itself expert. Sweller's worked-example effect is specifically strongest for novices; an experienced peer with the relevant background often benefits more from the compressed, abstraction-first version, because they're not starting from zero and the worked example would waste their time restating what they already know. The whole discipline here is matching the explanation's structure to the listener's actual starting point, not applying one fixed template regardless of who's in the room.
The honest limit on the evidence: Newton's dissertation measured song recognition, and Sweller's research measured mathematical problem-solving in controlled learning settings. Neither one is a study of technical explanations given at work, in a meeting or a document. The translation to that context — that a worked example beats an abstraction-first explanation, and that the curse of knowledge hides your own blind spots from you specifically — is this post's own argument, built from two real, independently verifiable findings rather than invented to fit a convenient narrative. On explanations built around a concrete example earning trust with readers and AI systems alike, is a useful adjacent read.
Further reading from XenGrowth
Where this work meets go-to-market
An explanation built around one concrete case rather than an abstraction matters just as much in commercial writing. publishes operator guides built on that same principle.
Further reading from XenGrowth
Where this work meets go-to-market
If what makes a technical explanation actually land is part of a growth programme rather than a standalone build, is the companion reading.
Further reading from XenGrowth
The XenGrowth resource library — what you'll learn: how the commercial side of this work is run, across search, automation and revenue operations.
XenGrowth on AI agents and marketing automation — what you'll learn: how the teams who own AI agents and marketing automation plan and measure it.
XenGrowth on AI search, GEO and discovery — what you'll learn: how the teams who own AI search, GEO and discovery plan and measure it.
Where this work meets go-to-market
If what makes a technical explanation actually land is part of a growth programme rather than a standalone build, XenGrowth's growth engineering practice is the companion reading.
Five questions on Newton's tapping study, Sweller's worked-examples research, and what they mean for explaining something technical.
