The Three Roles Are Becoming One (And That's a Problem)

For most of my career, the unicorn was someone who could design, build, and think strategically about product. Maybe one in fifty practitioners had all three. Teams would spend real money to find them.

That's over. The unicorn is now the default.

AI and modern tooling have compressed the skill floor across all three disciplines to the point where most practitioners can operate at a functional level in each. A developer can generate polished UI. A designer can prototype interactions that work. A PM can do both, often in the same afternoon. The overlap that used to be rare is now the baseline expectation on most high-functioning teams.

The problem isn't capability

Here's the thing: this isn't a problem of capability. It's a problem of what we're equating it with.

Role overlapping at 50% is not the same as going 100% deep in anything. But it's starting to look like it. And that's the quiet danger in how we're reading this shift.

When the tools do enough of the structural work, output quality converges. The PM's prototype and the designer's prototype start to look similar. The AI-generated component and the hand-coded one ship the same week. From a distance, the distinction disappears. From a distance, it looks like everyone can do everything equally well.

They can't. But increasingly, you can't tell until something fails.

What the tools can't replicate is the judgment that comes from going deep. Not the technique – the judgment. The designer who has spent fifteen years thinking about how people actually use interfaces has built a kind of perceptual system that fires before they can articulate why something is wrong. The developer who has built systems at scale knows which shortcuts will cost you six months in eighteen. The PM who has watched a product miss its market twice knows what a rationalization sounds like when a team is building for itself instead of for the user.

What the tools can't replicate

That depth doesn't show up in the output when everything is going smoothly. It shows up when something is about to go wrong.

The good news – and I do think there's good news here – is that the blurring creates something real: shared language. I've spent 23 years explaining design decisions to people who didn't have a framework for evaluating them. The new generation of practitioners who have worked across disciplines genuinely understands the trade-offs in ways that the siloed version didn't. That cross-discipline empathy is not nothing. It catches certain categories of failure earlier.

But it trades something in the process.

The good news has a cost

Here's what I think is actually at stake:

• Surface fluency scales — more practitioners, working faster, producing more

• Depth doesn't — the judgment in each discipline is still built over years of caring about one thing specifically

What I hope survives this transition is the practitioner who chose a discipline because they loved it, and who loves it enough to keep going deeper even when the tools make staying shallow look fine. Not out of nostalgia. Out of knowing that the users on the other end can feel the difference, even if they can't explain it.

Surface coverage is the new baseline. Depth is still what separates the good from the great.