Every developer knows the rubber duck moment. You start explaining a bug to a colleague, a chatbot or an actual plastic duck, and somewhere in the second sentence you hear yourself describe something that cannot possibly be true. Scale that moment up from one bug to an entire company and you arrive at the argument The Technology Podcast makes in its episode on tech podcasts as the new due diligence layer for innovation, namely that a guest who has to answer in real time, in front of a host who can always ask one more question, has nowhere left to park a weak claim. Cognitive scientists have been measuring a version of this effect for more than twenty years, and their findings boil down to a rule that engineers, founders and technical buyers can start using tomorrow: ask how, not why.

The Zipper You Think You Understand

In a series of studies published in 2002, Yale psychologists Leonid Rozenblit and Frank Keil asked people to rate how well they understood everyday devices: a zipper, a flush toilet, a cylinder lock, a speedometer. Then participants had to write step-by-step causal explanations of how a few of those devices work, and rate themselves again. The scores dropped. Nobody had been taught anything in between. Explaining simply exposed a gap that had been there all along, and the researchers named it the illusion of explanatory depth.

Two details from the paper should worry anyone who ships software. The illusion was strong for knowledge of how things work, smaller for facts such as national capitals, and absent for procedures such as tying a bow tie. That is the developer's trap in one sentence: knowing the procedure for using a tool feels exactly like knowing how the tool works. You know how to open a transaction or publish to a topic, and that fluency gets quietly promoted into an understanding of the machinery underneath.

The illusion was also most robust when the mechanism looked visible, as if seeing the parts were the same as knowing how they connect. That describes an architecture diagram uncomfortably well. Boxes and arrows make a system look explained, yet the arrow between the API and the queue is where retries, timeouts, ordering and partial failure actually live, and it is drawn with the same thin line as everything else.

Reasons Feel Like Knowledge. Mechanisms Test It.

In 2013, Philip Fernbach, Todd Rogers, Craig Fox and Steven Sloman took the idea from zippers to opinions. People rated how strongly they felt about several public policies and how well they understood them. Some then had to explain, step by step, how a policy would actually work. Others listed the reasons for their position. As cognitive scientist Tania Lombrozo explains in her breakdown of the study for NPR, the people who explained the mechanism rated their own understanding lower and moderated their views, while listing reasons did not have that effect. In a follow-up, the explainers were also less likely to donate to a group backing the side they started on.

Now look at how most technology gets presented. Faster. Safer. Cheaper. Enterprise-grade. AI-native. Those are reasons, and reasons make poor evidence. They are easy to rehearse, a language model will write a hundred of them before your coffee cools, and, as the experiment shows, they leave the speaker's illusion intact. The founder repeating them is usually not lying. They are under the same spell as their audience.

A mechanism question works differently, because nobody can walk through what happens when the primary database fails over mid-checkout without either knowing or visibly not knowing. It is also why "why" questions make weak design reviews. "Why did you choose Kafka?" invites a tidy list of reasons. "Walk me through what happens to this payment event if the consumer crashes after charging the card but before committing its offset" invites a mechanism, and the mechanism is where the duplicate charge is hiding.

Try It on Your Team's Most Confident Sentence

Here is a sentence said with total calm in a lot of planning meetings: "Postgres is ACID, so we can't double-spend." It sounds like understanding. Now explain it step by step.

Two requests try to withdraw $80 from an account holding $100 at the same moment. Each runs the obvious code: read the balance, check it in the application, write the new value.

BEGIN; SELECT balance FROM accounts WHERE id = 42; -- both requests read 100 -- application: 100 >= 80, so the new balance is 20 UPDATE accounts SET balance = 20 WHERE id = 42; COMMIT; 

Under Read Committed, PostgreSQL's default isolation level, the second UPDATE waits for the first transaction to commit, re-checks its WHERE clause against the new version of the row, sees that id 42 still matches and writes 20 again. Both withdrawals succeed. An account that held $100 has paid out $160 and still shows $20. The database kept every promise the acronym actually makes. The bug lives in the gap between the acronym and the mechanism.

The fixes are well known once somebody asks the question. Make the check and the write one statement (UPDATE accounts SET balance = balance - 80 WHERE id = 42 AND balance >= 80, treating zero updated rows as a rejection), lock the row first with SELECT ... FOR UPDATE, or use a stricter isolation level and retry on serialization failures, as the PostgreSQL documentation advises. None of these occur to a team whose explanation stopped at four letters.

A Duck That Asks Follow-Up Questions

Rubber duck debugging, popularized by a story in The Pragmatic Programmer in 1999, works for the same reason Rozenblit and Keil's participants lost confidence: explaining line by line forces you to produce the mechanism instead of the feeling of having one. But the duck never interrupts. It won't ask what happens if the second request arrives first, or what "anonymized" means when the dataset still holds ZIP codes and birth dates.

That interruption is what a good technical interview adds. The episode describes a strong host as the audience's stand-in, the person who keeps pressing for definitions, examples, numbers and consequences. In other words, a rubber duck that talks back, has never seen your architecture diagram and expects an answer before the silence turns awkward. A whitepaper is a set of reasons its author chose to include. A conversation keeps demanding the next link in the chain, which is why an hour of unscripted questioning can tell you more about a product than forty polished pages.

The same structure runs through every room where engineers get questioned, from design reviews and incident retros to an enterprise buyer's security questionnaire or the diligence call before an acquisition. In each of them, the question that separates understanding from its illusion is a "how" question asked by someone who is allowed to follow up.

Make the Answer Outlive the Conversation

Google's engineers wrote down the next step years ago. Google's guidelines for writing code review comments say that when a reviewer asks an author to explain a confusing piece of code, the usual right response is to rewrite the code more clearly (occasionally a code comment will do), because an explanation that lives only in the review tool does nothing for future readers.

The principle reaches far beyond code review. A mechanism you explained once, out loud, to one curious colleague is gone by Friday. When a follow-up question exposes a gap, the fix belongs where the next reader will look: a clearer code path, a test that pins the behavior down, a design doc, a public FAQ. Recorded interviews do this almost by accident, since a recording is searchable, quotable and hard to take back. That is what makes a vague answer so expensive on a podcast, and a precise one useful for years.

Run the Drill Before Someone Else Does

You don't need a podcast invitation or a term sheet to use any of this. A few habits move the test inside your own team:

  • Collect the confident sentences. Write down three claims your team repeats without blinking, such as "the cache keeps us fast," "the queue guarantees ordering" or "the model never sees personal data." The illusion lives in sentences nobody has been forced to unpack.
  • Rate, explain, re-rate. Score your understanding of each claim from one to seven, write the step-by-step mechanism without opening the docs, then score it again. The size of the drop tells you where to dig first.
  • Find the diagnostic question. After the general explanation, Rozenblit and Keil asked the kind of question experts consider central, such as how a cylinder lock can be picked. Your system has equivalents: what a user sees when they refresh one second after saving, or what happens to in-flight jobs during a deploy.
  • Trade one why for one how. In every design review, swap at least one "why did you choose" for "walk me through what happens when."
  • Recruit a duck that talks. Explain the system to someone from support, sales or another team, and give them explicit permission to interrupt. Every interruption you can't answer is a free finding.

Words Got Cheap. Mechanisms Didn't.

The episode makes a point that is easy to skim past: as machine-generated text floods every channel, an explanation that a specific person can be held accountable for becomes more valuable, not less. The research above suggests why. Reasons now cost nothing to produce, and even mechanism-shaped paragraphs can be generated on request. What cannot be generated is someone who actually knows the system answering the second and third follow-up without retreating into adjectives.

So the next time a vendor, a proposed architecture, a startup pitch or your own favorite design sounds convincing, skip the question about why it is better. Ask how it works, step by step, and keep asking until the answer reaches the bottom of the stack or stops. Then ask yourself the same thing, before somebody with a microphone does.