The New Product Designer Workflow

The product designer's job didn't change. The Double Diamond didn't change either. What changed is that one person can now run both diamonds end to end, and the cost of moving through them collapsed.

If you haven't seen it, the Double Diamond is a forty-year-old map of the design process. Two diamonds, four phases. The first diamond is about the problem: Discover, then Define. The second is about the solution: Develop, then Deliver. Each diamond does the same thing: diverge to open up possibilities, then converge to commit to one.

The old workflow was a relay across that map. A researcher discovered, a designer defined and developed, an engineer delivered, and signal leaked at every handoff. By the time it shipped, the design and the thing people used had quietly drifted apart.

The new workflow is the same four phases, run as a loop by one person. Here is what each phase looks like now.

Discover: diverge on the problem

It starts before any pixels. A ticket is rarely the real problem. It's someone's first guess at a solution. So the first move is to open it back up. What is the user actually trying to do? What are the edge cases nobody wrote down? What does success look like?

AI is a genuine thinking partner here. Not to answer the question, but to widen it, to surface the implied acceptance criteria, the forgotten states, the assumption buried in the title. The diverge half of the first diamond used to be expensive, so people skipped it. Now it's cheap, so you don't.

Define: converge on the goal

Then you narrow. Discovery is only useful if it resolves into a sharp problem statement everyone agrees on. You write the goal, the constraints, the definition of done. One clear thing you are actually solving.

This is the converge half, and it's still yours. AI can hold the options open. Deciding which problem is worth solving is judgment, and judgment doesn't generate.

Develop: diverge on the solution

Now the second diamond. Instead of committing to the first idea that survives a blank artboard, you generate several genuinely different ways to solve the defined problem. AI compresses the cost of exploring, so the question stops being "do I have time to try another direction" and becomes "which of these is right."

The craft layer sits inside this phase, unchanged. Figma is still where spacing, type, hierarchy, and motion get resolved, and that was never the bottleneck. And the evaluation moved earlier: you check the work against usability heuristics, accessibility, and the goal continuously, while it's still cheap to change, instead of as a gate at the end.

Deliver: converge on the shipped thing

The last phase is about making it real and making it match. This is the step that changed most. Instead of a clickable Figma file that fakes the experience, you prototype the real thing through AI, with real components, real data, and real responsiveness, and test it where it will actually live.

And the output is no longer a static file thrown over a wall. Sometimes it's a tested prototype and a tight handover. Sometimes it's a pull request draft: the change already in a branch, scoped to the visual layer, waiting for an engineer to review rather than translate from scratch.

The diamonds didn't change shape. AI widened the two diverge halves, because exploring the problem and the solution space got cheap. The two converge halves stayed human, because that's where judgment lives.

The designer didn't absorb engineering. They just stopped handing the design across four desks and watching it drift.