Why Do We Jump? About the Moment Before We Commit

Holding the Not-Knowing: What the "Anti-Jump" Looks Like

Design fog is what happens when we cross from the problem space into the solution space too early.

Before we understand the problem, we start building. We skip the questioning and investigating, jump the peak of the Double Diamond, and reach for a solution that feels like progress, but is really a shield against the anxiety of the blank page.

It is the "Ta-Da Flop" waiting to happen: presenting a near-finished solution only to watch it get rejected because it didn’t solve what was actually needed.

(See the Double Diamond graphic below for a visual of what jumping the peak looks like.)

 

If jumping too early is the default reflex, what does the "anti-jump" look like? It looks like staying in the fog on purpose. It means holding the state of not-knowing so we can question and investigate before we build. That is not stalling or bureaucracy. That is where good design inputs come from.

Here’s the thing about the jump: it doesn’t feel like failure in the moment. It feels like progress. That is exactly what makes it so hard to resist.

The Three Engines Behind the Jump

So then, why do we jump?

The fog has more than one engine. In this arc, we are covering three:

1. Speed (The Tool)
It is easier than ever before to start building things and to build them cheaply. We have digital twins, generative AI, additive manufacturing, and rapid prototyping tools. When building gets cheap, jumping gets easier. We trick ourselves into thinking that because we can fabricate something in an afternoon, we must understand what we are making.

2. Certainty (The Excuse)
When we are sure we already know the customer, the use environment, or the problem, we stop checking. We commit before we verify. This is also a classic trap in problem-solving: if we don't properly define the problem, we risk missing the root cause or the real solution entirely.

3. The Deeper Engine
Running underneath both speed and certainty is a third, deeper driver (the most human one of all). We are holding that engine back and saving it for the finale of this season.

The Arc Roadmap: Building One Idea

This episode is a map; our upcoming guests are going to fill in the stops.

Starting with this overview matters because naming these faces up front means each upcoming conversation lands inside a framework you're already holding. These aren’t isolated interviews; we’re using a pattern-spotting approach to build one continuous idea.

And throughout this arc, I’ll keep pointing you to one place to practice it: Pierce the Design Fog. Because the reflex may be human, but the way we train against it is structural.

Here is where we are heading:

• Next, on Speed: Ashley Roach joins us to discuss what happens when building becomes fast and cheap. He shares how the hard part shifts from "Can we build it?" to "Should I stop tweaking and put it in front of real users?" He reveals the trap of the "tweak loop" and shares his heuristic—the one-way vs. two-way door—as a test for whether an idea is safe to ship and learn from.
• Following, on Certainty: Another expert guest joins us to look at what happens when confidence outpaces evidence, and how customer assumptions quietly go stale.
• The Finale: We will ask: If speed is the tool and certainty is the excuse, what's underneath both? Why is the fog so hard to sit in? That conversation will bring the arc together.

A Question for Your Design Table This Week

To get started, subscribe to the podcast so you receive each episode as it releases.

And I’ll leave you with a simple reflection. When you catch yourself jumping this week, don’t judge it. Just ask yourself: "Did I jump because it was easy to build, or because I was certain I already knew?"

Start there. We’ll add the third question as we move through this arc.