The Double Diamond is Cracking

A team I worked with last year ran a textbook Double Diamond process. Six weeks of discovery—interviews, surveys, journey mapping. Four weeks of definition—synthesizing insights, prioritizing problems, aligning stakeholders. They emerged with a crisp problem statement and a clear design direction.

While they were defining, a competitor shipped the feature.

Not because the competitor was smarter. Because the competitor used an AI agent, skipped the diamond entirely, and had a working prototype in production before the first team finished their synthesis deck.

The first team did better work. They understood the problem more deeply. Their solution would have been more thoughtful. But they were playing a game designed for a world where execution takes months—and execution doesn't take months anymore.

The Double Diamond isn't wrong. It's built for a world that no longer exists.

The Hidden Assumption

The Double Diamond has been design's governing framework for two decades. Four phases, two diamonds, one sacred geometry:

→ Discover the problem space (diverge) → Define the right problem (converge) → Develop potential solutions (diverge) → Deliver the outcome (converge)

It gave design thinking structure. It legitimized research. It was elegant.

But it rests on a hidden assumption: execution is expensive.

The entire framework is a risk-mitigation strategy. You diverge and converge before building because being wrong in code costs weeks or months. You measure twice so you can cut once. The sequential phases exist to prevent waste—you don't commit engineering resources until you're confident you've found the right problem and the right solution.

This made sense when building a feature took a quarter. It made sense when the cost of a wrong bet was three engineers for six weeks. The Diamond was an insurance policy, and the premium was worth it.

But AI has collapsed the cost of execution. You can prototype a working solution in the time it used to take to debate the wireframe. You can ship, measure, and iterate faster than you can complete a discovery phase.

When building is nearly free, the insurance premium of sequential phases costs more than the risk it's insuring against.

Where the Diamond Cracks

The cracks show up in three specific places:

The handoff gap. The Diamond assumes clean handoffs between phases—discovery hands off to definition, which hands off to development. In practice, each handoff loses context. The researcher's nuanced findings get compressed into a problem statement. The problem statement gets compressed into a Jira ticket. The ticket gets compressed into a prompt. By the time the agent receives the instruction, it's three compressions away from the original insight.

The timeline mismatch. A proper discovery phase takes weeks. In that time, the market moves. User behavior changes. A competitor ships. The insight you validated in week two may be stale by week eight. The Diamond was designed for stable problem spaces. Most product teams don't operate in stable problem spaces.

The convergence trap. The Diamond's power is convergence—narrowing down to the single right problem and the single right solution before committing resources. But convergence assumes you can identify the right solution before building it. With AI, the fastest way to evaluate a solution is often to build it. Prototyping has become cheaper than analysis.

None of this means research doesn't matter. It means the sequence is wrong. Discovery and delivery aren't phases anymore—they're happening simultaneously.

The Artifact Problem

The Diamond's structure created a second, subtler problem: it turned process artifacts into deliverables.

Because the phases were sequential and distinct, teams started treating intermediate outputs—journey maps, personas, service blueprints—as things to polish and present. The journey map wasn't a diagnostic tool used to find friction. It was a deliverable with a due date, a stakeholder review, and a repository to maintain it in.

We've written about why this is a dead end. A journey map is like an X-ray: you take it to find the fracture, not to frame on the wall. When the artifact becomes the output, teams optimize for the quality of the map instead of the quality of the product.

The Diamond encouraged this by giving each artifact a ceremonial phase. Discovery produces research findings. Definition produces the problem statement. Development produces designs. Each phase has its deliverable. Each deliverable gets polished. And the actual user friction sits in a PDF that engineering never reads.

What Replaces the Diamond

Not a new shape. A loop. And it moves at the speed of execution, not the speed of process.

The loop has four steps, and none of them are phases:

1. Diagnose friction. Not "map the happy path." Find where the user is struggling right now—from support tickets, session data, research signals. The input is evidence, not intuition.

2. Specify intent. Don't design a screen. Define the outcome you need: what success looks like, what constraints apply, what edge cases exist. This is the Intent Spec—structured enough for an agent to execute against, precise enough for a human to verify.

3. Execute. Let the agent—human or AI—build against the spec. This used to take a quarter. Now it takes an afternoon. The execution step is no longer the bottleneck, and the process should stop treating it like one.

4. Verify. Did the friction decrease? Does the output satisfy the success criteria in the spec? If not, loop again. If yes, move to the next friction signal.

The loop isn't faster because it skips thinking. It's faster because it doesn't batch thinking into a six-week discovery phase that produces a static deliverable. Thinking happens continuously, in small increments, verified against reality at every turn.

Steering, Not Delivering

The Diamond taught teams to focus on "Delivery"—the big launch at the end of the second diamond. Ship the feature. Present the results. Move to the next project.

But in a continuous world, there is no launch moment. There is only steering.

When execution is instant, the designer's job shifts. You spend less time crafting the perfect solution and more time setting the constraints that prevent the wrong one. You evaluate AI outputs instead of producing artifacts. You define success criteria instead of drawing wireframes. You shape intent instead of polishing deliverables.

This is a harder job, not an easier one. The Diamond gave designers a clear sequence: research, then synthesize, then design, then ship. Steering requires you to do all of these continuously, in parallel, with no clean boundaries between phases. The craft doesn't disappear—it accelerates.

The Diamond implies a start and a finish. Steering implies you never stop driving.

The Double Diamond gave design thinking its structure. That was valuable. But the structure assumed a world where building was the expensive part—and in that world, investing weeks in convergence before committing to execution was rational.

That world is gone. Execution is cheap. Iteration is cheap. The expensive thing now is building the wrong thing fast—and the Diamond's sequential phases don't protect against that. Only continuous, evidence-based steering does.

The framework isn't dead. But the assumption it rests on is.