Recognizing bad strategy, even when it's well disguised

Description

In lesson 3 you classified the five sentences from Mercado's offsite, and the result was clear: two were a real strategy, three were bad strategy — Rumelt's term for a strategy that fails, not from bad luck in execution, but because it was never a real strategy to begin with. That lesson stuck, on purpose, with the easiest cases to spot: an empty aspiration ("leader of the region"), a numeric target ("grow 30%"). This lesson raises the difficulty. You're going to see two additional bad-strategy patterns Rumelt names in detail in his book — fluff (filler dressed up as sophistication) and the list of objectives disguised as strategy — and, most important for your judgment as an engineer, you're going to see a case where isRealStrategy gets it wrong, so you learn not to hand the final verdict to any model, not even your own.

Connection to the module. This lesson reuses isRealStrategy, built in lesson 3, on a second set of sentences — the ones that came out of Mercado's annual plan, weeks after the offsite. The model doesn't change a single line: the only difference is the difficulty of the cases you feed it. This same dataset extension is, moreover, the direct basis for the lesson 8 mini-project.

An analogy: the slogan that sounds like a plan

Imagine a political campaign whose slogan is "we're going to build a better future for everyone, with innovation and commitment." Nobody could disagree, and yet, after hearing it in full, you know absolutely nothing new about what that person would do in office that any other candidate wouldn't. Compare it with a real campaign slogan — whatever your view on its content — like "we're going to raise taxes on large corporations to fund free public education": there you do know something concrete, because the sentence names who pays for it (large corporations) and what for (free education). The first sentence is easier to say, and precisely for that reason, emptier. That contrast — language that sounds sophisticated versus language that actually chooses something, even if it's uncomfortable — is exactly what Rumelt calls fluff: using complex, abstract, or trendy words to give the sensation of strategic depth, with no real choice underneath those words.

Worked example: Mercado's second offsite

Weeks after the first offsite, Mercado's team met again for the annual plan. Three new sentences came out of that meeting. Let's run the same isRealStrategy from lesson 3 on them, without changing a single line.

function isRealStrategy(statement) {
  const text = statement.toLowerCase();
  const tradeoffSignals = ['instead of', 'in place of', 'sacrificing', 'at the cost of', 'we are not going to', 'giving up'];
  const vagueAspirationSignals = ['leading', 'number one', 'world-class', 'the best'];
  const bareGoalPattern = /\d+\s?%/;

  const hasTradeoff = tradeoffSignals.some((s) => text.includes(s));
  const hasVagueAspiration = vagueAspirationSignals.some((s) => text.includes(s));
  const hasBareGoal = bareGoalPattern.test(text);

  if (hasTradeoff) return { verdict: 'strategy', reason: 'declares a choice with an explicit trade-off: it says what it will NOT do, or what it sacrifices' };
  if (hasVagueAspiration) return { verdict: 'bad_strategy', reason: 'is a vague aspiration ("leading", "world-class") with no concrete choice behind it' };
  if (hasBareGoal) return { verdict: 'bad_strategy', reason: 'is a numeric target (a business goal), not a choice about where to play or how to win' };
  return { verdict: 'bad_strategy', reason: 'declares no identifiable choice or trade-off' };
}

const newStatements = [
  'Our strategy is to maximize omnichannel synergies by leveraging our ecosystem-centric value proposition.',
  'Our objectives are: grow GMV, improve NPS, reduce seller churn, increase buyer retention, and expand into 3 new countries.',
  'We are going to focus on the customer instead of the competition.',
];

console.log('=== Second offsite: new statements from the annual plan ===\n');
newStatements.forEach((s, i) => {
  const r = isRealStrategy(s);
  console.log((i + 1) + '. "' + s + '"');
  console.log('   -> ' + r.verdict + ' (' + r.reason + ')\n');
});

What to expect. Running the file with Node, the output is exactly this:

=== Second offsite: new statements from the annual plan ===

1. "Our strategy is to maximize omnichannel synergies by leveraging our ecosystem-centric value proposition."
   -> bad_strategy (declares no identifiable choice or trade-off)

2. "Our objectives are: grow GMV, improve NPS, reduce seller churn, increase buyer retention, and expand into 3 new countries."
   -> bad_strategy (declares no identifiable choice or trade-off)

3. "We are going to focus on the customer instead of the competition."
   -> strategy (declares a choice with an explicit trade-off: it says what it will NOT do, or what it sacrifices)

The three sentences deserve a separate read, because each one proves something different about the model's limits.

Sentence 1 is fluff in its purest form: "maximize omnichannel synergies by leveraging our ecosystem-centric value proposition" sounds, at first listen, more sophisticated than "we're going to be the leader of the region" — it uses consulting vocabulary, borrowed jargon, the word "strategy" right there in the sentence. But strip away the varnish and it says absolutely nothing verifiable: what is an "omnichannel synergy"? Which channels, specifically? What gets sacrificed to achieve it? The model correctly classifies it as bad_strategy, not because it recognizes fluff as a concept — the model doesn't "understand" anything — but because, as it happens, none of the complicated words activate the trade-off signal. Fluff, by its very nature, almost never contains an explicit trade-off — it is, precisely, language designed to sound confident without committing to anything — and that's why it almost always falls into the model's default branch.

Sentence 2 is the second bad-strategy pattern Rumelt names: a list of objectives disguised as strategy. Five separate targets — GMV, NPS, churn, retention, expansion into three countries — presented together, with no priority order and no choice of which matters more than the rest. Rumelt is blunt about this: a list of objectives is not a strategy, even if each individual objective is reasonable, because it doesn't say how they get achieved, and above all it doesn't say what gets sacrificed when two of those five objectives collide (what happens if expanding into three new countries requires spending the budget that would have lowered seller churn?). The model correctly flags it as bad_strategy.

Sentence 3 is the most important of the three, because here the model gets it wrong. "We are going to focus on the customer instead of the competition" contains the instead of signal, so isRealStrategy classifies it as strategy. But read it carefully: which specific customer segment? What would Mercado actually do differently, in practice, if it "focused on the customer" instead of "on the competition"? The sentence has the grammatical shape of a trade-off — an "instead of" placed just right — but it names no concrete or verifiable sacrifice. It is, at bottom, just as empty as "we're going to be the leader of the region," only better disguised: someone learned that sentences with "instead of" sound like real strategy, and built one that has the shape without the content.

Why the model gets it wrong, and what to do about it

isRealStrategy looks for a surface signal — certain words and text patterns — not the real content of the choice. That makes it fast and useful as a first filter over a large set of sentences, but it also makes it gameable: anyone who knows which words trigger the strategy verdict can write a sentence that contains them without committing to anything real. This isn't a flaw you can fix by adding more words to the signal list — it's a structural limitation of any model that judges text by surface patterns instead of real meaning, and it's exactly why this module, since lesson 3, has insisted that the model structures judgment, it doesn't replace it.

The real test, the one no text model can fully automate, is this: is the named trade-off specific and verifiable? Compare sentence 3 from this lesson ("we focus on the customer instead of the competition" — vague, doesn't say which customer or which action changes) with sentence 5 from the original offsite in lesson 3 ("we are not going to build a better search engine than the generic giant; we invest that effort in human curation and trusted local sellers instead" — specific: it names the exact action that does NOT happen, and the exact action invested in instead). The difference isn't in the grammar of the two sentences — both use a trade-off construction — it's in whether, after reading them, you know something new and actionable about what the team is going to do differently. That question, "do I know something new and actionable after reading this?", is the final check you have to apply yourself, after the model runs its first quick filter.

Common mistakes

Trusting the model's verdict without reading the full sentence. What happens: someone runs isRealStrategy on a long planning document, sees several sentences come back marked as strategy, and accepts them as real strategy without rereading them with human judgment. Why it happens: an automated verdict feels more objective and definitive than a critical read of your own, even though the model, as you just saw, can be fooled by a single well-placed word. How to spot it: it's, literally, the case of sentence 3 in this lesson — it passes the filter, and yet it says nothing specific. How to fix it: use the model as a quick first filter over a large set of sentences, never as the final verdict. Any sentence the model flags as strategy still needs the human question: is this specific and verifiable, or does it just have the right shape?

Using the word "strategy" to lend weight to a list of objectives. What happens: a document titles a section "Our Strategy" and lists several business targets underneath — just like sentence 2 in this lesson — as if the title alone turned the list into something other than what it is. Why it happens: the word "strategy" sounds more authoritative and more rigorous than "objectives" or "targets," and using it feels like elevating the document without having to do the real work of choosing. How to spot it: if you can reorder the list's items without the meaning changing — sentence 2's five objectives work in any order — that's a sign there's no hierarchy or real choice behind it, just an enumeration. How to fix it: a list of objectives becomes a strategy when someone explicitly decides which of those objectives wins when two of them collide, and what gets sacrificed to pursue the priority one. Without that decision, it's still just a list, no matter what title sits above it.

Learning to "hack" the criterion instead of reasoning with it. What happens: someone, after seeing isRealStrategy's criterion, starts writing sentences that deliberately contain the words that trigger strategy ("instead of," "sacrificing"), without the underlying choice being real — exactly what happened, without bad intent but with the same effect, in sentence 3 of this lesson. Why it happens: once a criterion becomes known, it's tempting to optimize for passing it instead of optimizing for the real goal the criterion was trying to measure — it's the same phenomenon, at small scale, that happens whenever any metric turns into a target. How to spot it: the sentence sounds like a formula ("X instead of Y") without X or Y being specific or verifiable. How to fix it: always remember the underlying question behind the criterion — it isn't "does it contain the right word?", it's "did I choose something real, with a real cost?" The text criterion is a shortcut toward that question, never a substitute for it.

Exercises

Exercise 1 — Find the fluff. Rewrite sentence 1 from this lesson ("maximize omnichannel synergies by leveraging our ecosystem-centric value proposition") in plain English, with no buzzwords, the way you'd explain it to a relative who doesn't work in tech. What does the exercise tell you about how much real content the original sentence had?

Exercise 2 — Fix the sentence that fooled the model. Take sentence 3 from this lesson ("we are going to focus on the customer instead of the competition") and rewrite it so it keeps the trade-off structure but is now specific and verifiable — it should still classify as strategy, but this time for a reason of content, not just shape.

"We are going to invest this quarter's budget in interviews and
direct support for frequent buyers, instead of monitoring the
generic giant's prices to match them week over week."

Exercise 3 — Design your own trap for the model. Write a new sentence, different from the ones in this lesson, that contains one of the trade-off signals (tradeoffSignals) but that, read with human judgment, turns out just as empty as sentence 3. Then, explain in one sentence why it fools the model.

Summary and next step

In this lesson you deepened your ability to recognize bad strategy beyond the obvious cases: you saw fluff (sophisticated language with no content, sentence 1) and the list of objectives disguised as strategy (sentence 2) — two patterns Rumelt names in detail, and that isRealStrategy correctly detects, even if for a different reason than "understanding" the fluff or the list. And, most importantly, you saw a case where the model gets it wrong (sentence 3): a sentence with the correct grammatical shape of a trade-off, but with no specific or verifiable content behind it — proof that no text criterion replaces the final question: do I know something new and actionable after reading this?

Before moving on you should be able to: name the three bad-strategy patterns seen in the module (empty aspiration, numeric target, fluff/list of objectives); explain why a sentence can have the correct shape of a trade-off without being a real choice; and apply the "do I know something new and actionable?" test to any sentence presented as strategy.

With this you reach the end of the module's content lessons. Lesson 8, the mini-project, brings together the module's two full models — isRealStrategy and outcomeOf — over Mercado's complete board deck: you're going to audit every strategic sentence the team has produced so far, and calculate, with numbers, exactly how much it would cost Mercado to pursue the wrong sentence with flawless execution.

Resources

• Richard Rumelt, Good Strategy Bad Strategy: The Difference and Why It Matters — penguinrandomhouse.com/books/208668. The original source of "fluff" and of "mistaking goals for strategy" — this lesson's two central patterns, with many more real company examples. In English.
• Richard Rumelt, "The Perils of Bad Strategy" (McKinsey Quarterly) — mckinsey.com/capabilities/strategy-and-corporate-finance/our-insights/the-perils-of-bad-strategy. A summary of the book's central argument, published as a standalone article, with the historical example of the Battle of Trafalgar. In English.