Will AI replace product designers? Not the ones companies actually need.

The silent question every PM is asking right now goes something like this. They have the objectives mapped out. They have the user stories, the acceptance criteria, the requirements doc, and the ticket queue. They've stacked a UI-designer skill, a UX-designer skill, a UX-research skill, a usability-testing skill, a heuristics skill, and an accessibility skill on top of Claude or some other capable model, in the form of careful prompts that walk the model through each lens of design competence in turn. They feed the requirements in. The model spits out a product that is designed, accessible, and on-brand. It works. It's shippable.

Do they still need a designer?

The honest answer is yes, but not for the reason most designers reach for when they hear the question. The case isn't that AI can't execute, because it can, and it's getting better at it every quarter. The case is that AI plus a PM is a permutation engine, and what permutation engines produce at scale is sameness. Every product built this way starts to look like every other product built this way, because they're all sampling from the same training distribution with the same kind of skill-stack on top of it.

I've started calling this permutation collapse, the convergence to visual and structural sameness when generative systems are the dominant production mode. It's the load-bearing wall under the case for keeping designers around in companies that care about a unique product.

The rest of this piece is about what permutation collapse actually is, why the PM-plus-AI stack is a real thing that does real work, what that stack ships that's almost-good but not quite, and where the design role moves when execution stops being the scarce resource on the team.

What I mean by "permutation collapse."

LLMs produce design output the same way they produce text output. They sample from a distribution of patterns they've seen during training, weight those patterns against the prompt's constraints, and emit something that's a recombination of existing solutions. That isn't a criticism of the technology; it's just an honest description of how it works. Permutation and combination of what already exists is the engine.

The basic statistics of this are worth thinking through. As the number of permutations across a fixed set of inputs grows, the probability that two distinct outputs land near each other in design space grows along with it. Two products giving Claude similar requirements will get similar outputs. Two designers running the same skill-MD stack will produce similar UI vocabularies. Two startups in the same category, prompting the same model with the same JTBD framing, will ship products that look like cousins of each other.

That's permutation collapse. It isn't "AI design is bad." AI design is fine. AI design is converging.

You can already see the early signal of this if you've been looking. The same input affordances. The same modal patterns. The same hero composition. The same chat-with-suggestions architecture. The Figma file from one Series A startup looks like the Figma file from the next one because both teams are pulling from the same surface vocabulary in the same way.

The product that breaks out of permutation collapse needs an input the model doesn't have access to: a human making a non-average call about something fundamental.

Why the PM-plus-AI stack actually works.

Worth being honest about this part. The stack does work, and it works for a real and growing class of problems. I'm not making the argument that designers are still needed because AI can't execute. They're needed because of what AI executes toward.

The PM-plus-AI stack ships well in several places:

• Generic CRUD admin panels. Standard list views, forms, detail screens. There is no unique product to be expressed here, and permutation-engine output is fit-for-purpose.
• Internal tools. Speed and clarity matter; differentiation doesn't. The averaged output is often better than what an under-resourced design function would produce against the same brief.
• Early-stage MVPs validating a hypothesis. When the goal is to find out whether anyone wants the thing, not to ship the canonical version of it, the AI-stack approach gets you to user signal weeks faster than a research-first design process ever would.
• Well-trodden patterns in a competitive but not differentiating space. A second-best login flow, a standard checkout, a stock onboarding shell. There's no design moat in any of those, and trying to manufacture one wastes the cycle.

A pre-AI version of this argument has always been true. Not every product needed a senior designer; some needed someone who could ship competent execution against a clear brief. AI has just collapsed the cost of that work to near zero. The companies that were never going to prioritise design as a strategic function aren't going to start now, and that isn't a tragedy; it's a clarification.

The clarification is what helps make the case for where designers do belong.

What that stack ships, and where designers earn their keep.

The PM-plus-AI stack ships almost-good. Every output is competent. Every output is on-trend. Every output is interchangeable with the equivalent output from a competitor running the same stack. That's the shape of the problem worth solving.

What the stack can't ship is the principle that organises the work. The non-obvious strategic call about which trade-off the product is making and why. The interaction model that doesn't exist in the training corpus because nobody has tried it yet. The voice that sounds like a specific company instead of like a sample of all companies in the category.

A concrete from my own work. On the Salsify Angie copilot, the strategic call I made was where the AI auto-fixes and where it stays out of the way, drawn around consequence reversibility. That wasn't a permutation of design patterns. It was a judgment about what kind of risk Salsify wanted to take with Kroger's catalogue and what trust contract the product was offering its enterprise users. No skill-MD stack derives that. No PM-with-Claude stack derives that. It came out of a designer holding the position long enough to convert the principle into a one-page doc that product and engineering both co-signed. The principle now travels: every subsequent AI feature on the platform gets sorted through it.

A second concrete from a different domain. On the OneClick shift-management redesign, the move that did the heavy lifting was a quiet one. The new defaults out-performed the old power-user shortcuts by a clear margin. That isn't a UI decision the model would have made on its own; it required someone to argue, against the loud users, that trusting the system to make a sensible first move is the better experience for the silent majority. The team gained roughly 18% market share in the period that followed.

Both of those are judgment work, not execution work. The execution was downstream of the call. And that's where design's value moves when AI handles the pixels.

The new shape of design work.

Less making, more judging. Less Figma, more Dovetail. Less time on the artefact itself, more time on the principle the artefact is meant to express.

In practice, the day-to-day shifts in three ways.

From producer to QA. A growing fraction of senior design work is reviewing AI-generated surfaces and naming what's missing. Not the obvious bugs, but the absence of point of view. "This is technically right and emotionally neutral. Where's the opinion?" That question is the new crit, and it can't be automated because answering it requires comparing the output against what the product is trying to be, which is a human-held intention that lives outside the model.

From specs to principles. The artefact that ships is no longer the variant chosen but the documented principle that should govern future variants. The reversibility rule. The single-first-win heuristic. The two-flow blind-feedback ritual. Each of these is a load-bearing decision worth more than the dozen mocks that surrounded it on the way in.

From research-as-input to research-as-loop. When AI handles execution, the bottleneck on the loop is no longer how fast a designer can mock; it's how fast you learn from real users in front of the work. Senior designers spend more time in user observation, more time synthesising what they hear, and more time turning that into next-round briefs. The five-user-per-round model from prototype-as-probe is the operating cadence of this version of the role.

The execution-focused designer becomes the design-judgement specialist over time. Less loud, less photogenic, much harder to hire for, and substantially more valuable to a company that wants its product to look like itself rather than like the category average.

One more counterargument, resolved.

The strongest critique of this piece is that it sounds like designers defending their jobs, and it is partly that. Every profession looks for the framing that justifies its continued existence, and senior designers are not exempt from that incentive.

Two responses.

The first is that you should weight the argument accordingly. If you believed everything every threatened profession said about its own indispensability, you'd hire a typewriter repair specialist. So discount the case I'm making by however much you discount this kind of argument generally, and see what's left.

The second is the part that isn't job-defence. The case isn't we still need designers. The case is if you want a unique product, you need design judgement somewhere in the loop, and that judgement is the work that doesn't permutation-collapse. If your product strategy depends on competing in a category where differentiation matters (most B2B SaaS, most consumer-facing tools, most premium-tier anything) and you go all-AI on design, you ship a product that converges with everyone else's. That's a strategic position. It's not the position that will win the categories worth winning.

Early-stage startups validating an idea may correctly skip dedicated design. Mature companies serious about an unmistakeable product will keep design, just for different work. The execution function shrinks. The judgement function gets central. The role title may or may not change. The job changes either way.