Past behavior, not future intentions

Overview

In the module overview you saw the problem in its smallest form: the same curiosity, asked two ways, produces completely different data depending on whether it asks for a prediction or a fact. This lesson stops there and builds the tool you need to recognize the difference systematically, not just by intuition: detectTense(), a classifier that looks at an interview question and says whether it points at the past (real behavior, already happened, verifiable) or the future (an intention, a promise, something the person hasn't done yet and might never do).

How this connects to the module. This is the first piece of the full classifier you're going to assemble in lesson 4 (classifyQuestion) and use unchanged in lesson 7 and the final project. Everything that follows in the module —the Mom Test, leading questions, the say-do gap— is, at bottom, a different way of protecting this same idea: what someone says they would do isn't what someone did.

An everyday analogy: ask for the receipt, not the promise

You already saw the gym analogy in the module overview. Take it one step further: imagine you're a cashier at a store and someone tells you "I'm coming back next week to buy double." You can jot that promise down in a notebook, but you can't ring it up at the register — it isn't a sale, it's an intention. The only thing that counts for the business is the receipt: the purchase that already happened, with a date, an amount, and a product, verifiable because it's printed on paper.

A product interview works the same way. When you ask a Mercado buyer "would you buy more if you saw recommendations?", you're asking them to hand you a promise, not a receipt. And promises, in an interview, almost never cost anything: saying "yeah, sure" is free, sounds cooperative, and wraps up the question quickly. The receipt —"the last time I bought something because of a recommendation from another store was last month, a phone charger I saw on Amazon"— takes more mental effort to invent if it isn't true, and that's exactly why it's much more reliable.

Worked example: detectTense() over five candidate questions

This is the first draft of questions Mercado's team wrote to understand whether buyers would respond to recommendations. Before using them with a real user, we run them through a simple classifier that only looks at the question's implicit tense: does it ask for something that already happened, or something that might happen?

// L2: we tell apart whether a question points at the past (real behavior) or the future (intent).
function detectTense(question) {
  const q = question.toLowerCase();
  const futureSignals = ['would you use', 'would you buy', 'would you like', 'would you pay', 'would you install', 'would you prefer'];
  const pastSignals = ['what did you do', 'when was the last time', 'how did you solve', 'what did you use', 'do you remember the last time'];

  const isFuture = futureSignals.some((s) => q.includes(s));
  const isPast = pastSignals.some((s) => q.includes(s));

  if (isFuture) return { question, tense: 'future', verdict: 'risk: asks for a prediction, not a fact' };
  if (isPast) return { question, tense: 'past', verdict: 'good: asks for a verifiable fact' };
  return { question, tense: 'unclear', verdict: 'no clear signal, review carefully' };
}

const candidateQuestions = [
  'Would you use a personalized recommendations feed if Mercado launched it?',
  'When was the last time you bought something because of a recommendation from someone else (a friend, a review, another store)?',
  'Would you like Mercado to suggest products to you automatically?',
  'What did you do the last time you couldn\'t find what you were looking for on Mercado?',
  'Would you buy more if you saw recommendations on the home page?',
];

console.log('=== detectTense() over 5 candidate questions ===\n');
candidateQuestions.forEach((q) => {
  const r = detectTense(q);
  console.log('  [' + r.tense.toUpperCase().padEnd(7) + '] ' + r.question);
  console.log('  -> ' + r.verdict + '\n');
});

What to expect. When you run the file with Node, the output is exactly this:

=== detectTense() over 5 candidate questions ===

  [FUTURE ] Would you use a personalized recommendations feed if Mercado launched it?
  -> risk: asks for a prediction, not a fact

  [PAST   ] When was the last time you bought something because of a recommendation from someone else (a friend, a review, another store)?
  -> good: asks for a verifiable fact

  [FUTURE ] Would you like Mercado to suggest products to you automatically?
  -> risk: asks for a prediction, not a fact

  [PAST   ] What did you do the last time you couldn't find what you were looking for on Mercado?
  -> good: asks for a verifiable fact

  [FUTURE ] Would you buy more if you saw recommendations on the home page?
  -> risk: asks for a prediction, not a fact

Of five candidate questions, three ask for a prediction and two ask for a fact. Notice something important: all five questions sound equally reasonable read quickly in a meeting — none of them would be rejected at a glance for "sounding wrong". detectTense()'s value isn't doing something a well-trained human couldn't do carefully; it's doing it fast and without exceptions, over a full script, before you sit down in front of a real user. It's the same discipline you'd apply to a spelling check: anyone can catch an error if they focus on a single word; an automated checker does it across a hundred pages without tiring.

Notice also what isFuture does with the first three flags: it doesn't care whether the question sounds polite, formal, or comes with extra context ("if Mercado launched it") — the pattern 'would you use', 'would you like', 'would you buy' is enough to flag it as risky. This is intentional: in the Mom Test (next lesson) you'll see this kind of opener almost always gives away a hypothetical question, no matter how much context gets added afterward.

Why the future is so cheap to answer yes to

There's a psychological reason behind why "would you use X?" almost always gets a "yes": saying yes to a hypothesis costs the person nothing in that moment. They don't have to reorganize their budget, don't have to change a habit, don't have to commit to anything verifiable — they just have to imagine a version of themselves who says yes, which is exactly what almost any polite person does in front of someone excitedly showing them an idea. The courtesy "yes" isn't a conscious lie; it's the lowest-social-friction response to a question that costs nothing.

Asking about the past breaks that dynamic because the past already happened, and it can't be negotiated. The person can't decide in the moment "I'm going to buy more if I see recommendations" because the question isn't asking for a decision — it's asking for a memory. And memories, even though they too can be inaccurate (memory fails, people reconstruct), are much harder to invent out of thin air than a promise about something that's never actually going to happen during the interview.

Common mistakes

Asking "would you use X?" and believing the courtesy yes. What happens: Mercado's team asks ten buyers "would you use personalized recommendations?", all ten say yes, and the team reports "10 of 10 validated the idea" at the next planning meeting. Why it happens: a "yes" feels like real validation, especially when it comes from ten different people and nobody said no — unanimity gets confused with solid evidence. How to spot it: if none of the answers include a specific detail, a date, a concrete example — just "yes, I'd like that" repeated ten times — you don't have ten pieces of evidence, you have ten courtesies. How to fix it: every time the answer to a future question is "yes", ask the past follow-up: "and when was the last time you did something similar?". If there's no concrete answer to that second question, the original "yes" is worth almost nothing.

Softening the past question until it turns back into a future question without noticing. What happens: someone starts with a good question ("when was the last time you bought something because of a recommendation?") but, not getting an immediate answer, reformulates it on the spot to "well, but would you like us to recommend things to you?" — and ends up getting the hypothetical answer anyway. Why it happens: the awkward silence after a hard question creates the temptation to rescue the conversation with an easier question to answer — and future questions are almost always easier to answer quickly. How to spot it: review the transcript and look for patterns where a past question gets no answer and is followed, in the same turn, by a future question. How to fix it: train your tolerance for silence — if the person doesn't remember right away, give them a few seconds before rephrasing, or ask "take your time, does anything come to mind, even from another store or app?" instead of jumping to the future.

Exercises

Exercise 1 — Classify without running Node. For each question, say whether detectTense() would flag it future, past, or unclear, and why:

• (a) "Would you pay for a priority shipping plan?"
• (b) "What did you use the last time you didn't know what to buy for a gift?"
• (c) "What do you think of personalized recommendations in general?"

See solution

• (a) future. Contains the signal 'would you pay', which is in futureSignals. It asks for a prediction about a payment behavior that never happened.
• (b) past. Contains the signal 'what did you use', which is in pastSignals. It asks for a concrete fact: what tool or method the person used in a real situation they already lived through.
• (c) unclear. It contains none of the signals from futureSignals or pastSignals — it doesn't start by asking for an explicit prediction, but it also doesn't ask for a specific past fact. It's actually a general opinion question, a different problematic question type lesson 3 (the Mom Test) is going to name explicitly.

Exercise 2 — Rewrite three future questions. Turn these three hypothetical questions into questions detectTense() would flag as past:

• (a) "Would you install a Mercado app just for sellers?"
• (b) "Would you prefer to receive recommendations via notification or inside the app?"
• (c) "Would you like to be able to save products for later?"

See solution

• (a) → "What did you use the last time you managed your inventory as a Mercado seller?"
• (b) → "When was the last time you received a notification from an app and opened it right away? What did it say?"
• (c) → "Do you remember the last time you wanted to buy something but not right then? What did you do to not lose track of it?"

The common pattern: swap the conditional/future verb ("would install", "would prefer", "would like") for a question that starts by asking for a specific moment already lived — "the last time...", "when was...", "what did you use...".

Exercise 3 — Design the edge case. Write a question a human would easily recognize as a "future question disguised as a past one", but that detectTense() would classify as past (a false positive). Explain why the classifier gets it wrong in this case.

See solution

An example: "What did you do the last time you dreamed about having perfect recommendations on Mercado?". It contains the signal 'what did you do', so detectTense() would flag it past — but it's actually asking for a fantasy, not real behavior. The classifier fails because it only looks for opening phrases, it doesn't understand the semantic content of what comes after. This confirms, with a concrete example, the module overview's warning: detectTense() is a text-based heuristic classifier, not a model that understands meaning — a fast support tool, not a replacement for the judgment of whoever writes and listens to the question.

Summary and next step

This lesson gave you the module's first real classifier piece: detectTense(), which tells apart past behavior questions (past, the "receipt") from future intent questions (future, the "promise"). You saw, run live, that of five candidate questions from Mercado's script, three asked for a prediction and only two asked for a fact — and you understood why saying "yes" to a future question costs almost nothing, while a specific past memory is much harder to invent on the spot.

Before moving on you should be able to: recognize, without help from code, whether a question asks for a fact or a prediction; and rewrite a future question as a past question, following the "the last time..." pattern.

Lesson 3 broadens this same principle with a complete framework: Rob Fitzpatrick's Mom Test, which protects not only against future questions, but also against two more traps — talking about your idea instead of the user's life, and asking for opinions instead of facts.

Resources

• Rob Fitzpatrick, The Mom Test — momtestbook.com. The book the next lesson develops in depth; its second rule ("ask about specifics in the past, not generics or opinions") is exactly this lesson's principle. In English.
• Teresa Torres, "Why You Are Asking the Wrong Customer Interview Questions" — producttalk.org/customer-interview-questions. Explains, with the jeans-shopping example, why asking "tell me about the last time..." gives better data than asking about general preferences. In English.
• Nielsen Norman Group, "User Interviews 101" — nngroup.com/articles/user-interviews. Explains social desirability bias — why people answer what they think is expected of them — the psychological reason behind the free "yes" to future questions. In English.