Design's Superpower Isn't Taste. It's Clarity.

Real learnings about what AI-native product teams actually need from design leaders.

We’ve been going hard on AI-native product development workflows. Research synthesis, PRD generation, design artifacts, critique loops, handoff prep — all of it, with AI deeply in the loop.

The tools work. That was not the hard part.

The surprising thing wasn’t what AI could produce. It was what it exposed about how we’d been working all along.

There’s a popular narrative that design’s value in the age of AI is taste — the human eye that says “not that, this.” I think that undersells us. Taste matters. But what organizations actually need from design right now is clarity. The ability to wade through ambiguity, make invisible systems legible, and give teams something they can act on. That’s always been the real (often under-appreciated) superpower, and AI just made it an urgent need.

---

The Buffer

Here’s what I didn’t expect.

The old product development process had shock absorbers we never realized. Meetings where people quietly aligned on things that were never written down. Hallway conversations that resolved ambiguity nobody had formally surfaced. Design reviews that were really translation sessions — designers decoding what product actually meant, engineers decoding what designers actually intended. PMs who held critical context in their heads and dispensed it as needed.

None of this was in any process document. It was human labour — invisible, unacknowledged — absorbing the ambiguity that the formal process couldn’t handle.

We called it process, but it was actually a buffer.

When we started building shared context repositories for our product teams — trying to give AI agents the same ambient knowledge that humans carried in their heads — we found something we didn’t expect. Different artifacts were making contradictory claims about the same feature. Not because anyone was wrong. Because context had always lived in people’s heads, and different people held different versions of the truth. The hallway conversations had been quietly resolving those contradictions in real time. With an agentic process, they remain unresolved.

AI compressed the production timeline. Buffers disappeared, and suddenly the ambiguity they’d been absorbing was sitting in the open, with nobody to clean it up.

AI did not break the process, but it exposed the parts humans had been quietly holding together, or even more critically, shone a light on where proper process didn’t exist!

---

What Broke

When we pushed AI-native workflows hard, the failures weren’t where we expected. The tools were fine. The system around them started cracking.

Here are some examples:

Generated looked too much like approved. AI produces polished output. Polished output looks done. We started seeing teams consume artifacts that hadn’t been reviewed, let alone approved. A generated PRD looks as professional as an approved one. A first-pass design exploration looks as finished as a vetted direction.

If everything looks polished, nothing looks provisional.

PRDs tried to hold everything. As AI made it easier to generate comprehensive documents, PRDs started absorbing product scope, architecture decisions, UX rationale, analytics requirements, GTM strategy, and implementation questions — all in one artifact. The PRD became a junk drawer of unresolved decisions dressed up as completeness.

Engineering could pull faster than teams could clarify. When coding agents can move from spec to prototype in hours, the upstream pressure is enormous. Engineering doesn’t want to wait — and shouldn’t have to. But if the artifacts they’re pulling from haven’t gone through real review, you get speed without coherence.

Context lived everywhere and nowhere. Research in one tool. PRDs in another. Design rationale in Figma comments. Decisions buried in Slack threads. AI made each artifact faster to produce but didn’t solve context fragmentation — it amplified it. More artifacts, produced faster, scattered across more surfaces.

Atlassian calls this the “AI fragmentation tax” — faster individuals don’t automatically create faster organizations. That matched what we were seeing. Every person got faster. The team didn’t.

The old process was designed for scarce production. We now live in a world of abundant artifacts. The operating model hasn’t caught up.

---

Why This Is Design Leadership’s Moment

Here’s the thing about this problem: it’s not a tooling gap. It’s not a project management gap. It’s a clarity gap.

Design earns its seat at the table when it moves beyond artifacts and starts shaping how a product organization delivers work. Not just the screens. Not just the system. The operating model itself — who decides what, when something is ready, how context travels, and what “good enough” means at each stage.

In my last article, I argued that design’s job shifted from production to direction. I’d push it further now: the direction that matters most is the upstream clarity that makes everything else actionable. When the build can happen in hours, unclear direction doesn’t just delay one team — it compounds across every team consuming your artifacts, burning time and trust in parallel.

Design leaders are trained in research, synthesis, systems thinking, and making the ambiguous concrete. That’s exactly the work this moment demands. And it’s why the shift-left argument — design getting upstream before engineering starts building — just became existential.

Design’s next mandate is not to slow AI down. It is to make AI-speed work coherent, accountable, and worth shipping.

---

What Helps

This isn’t theoretical. These are the moves we’re learning matter most. If you want a place to start: take the next AI-generated PRD or prototype that crosses your desk and ask four questions. What artifact is this? What state is it in? Who is accountable for its claims? What can the next team safely build? The answers — or the silence — will tell you where to focus.

Make the work legible

Map the real path from idea to outcome. Not the process deck version — the actual one. Find where context disappears, where ownership blurs, where teams pretend something is ready before it is.

Designers are trained to make invisible systems visible. The same skill that maps a user journey can map how a feature moves through your organization. Most teams have never done this honestly. Now they have to. You can’t fix what you can’t see — and most operating models have never been designed at all. They just happened.

Shift left into clarity

“Shift left” used to mean getting design involved earlier in sprints. Now it means something bigger: helping the organization get clear before the agents start running.

What are we trying to deliver? Why does it matter? How does it fit the broader vision? What evidence supports it? What’s still open? What’s stable enough to build from?

These are clarity artifacts — the working objects that make direction usable before AI-speed execution begins. An outcome brief that says why this matters. An evidence summary that grounds the bet. An assumption list that names what’s still unproven. A decision log that tracks what changed and who called it. A readiness contract that says what the next team can trust. A dependency map that shows what must line up.

The point isn’t more documentation. It’s fewer ambiguous artifacts with clearer jobs and better judgment behind them. Without clarity artifacts, every team downstream is making assumptions — and assumptions compound fast.

Create readiness contracts

Generated is not approved. Reviewed is not approved.

Readiness is not a visual state. It’s a contract. When a team marks something as “engineering-ready,” that should mean something specific and accountable — the scope is locked, the open questions are resolved, the dependencies are visible, and a named person has made the judgment call that it’s stable enough to build from.

When AI makes every artifact look polished, the difference between exploratory and approved can’t rely on how finished something appears. It has to be explicit. A readiness contract says: here is what this artifact promises, here is what it doesn’t, and here is who is accountable for that boundary.

This is where design leaders can drive real organizational change — not by designing a status badge, but by designing the agreement structure that makes handoffs trustworthy.

Redesign the artifact system

Stop making the PRD hold everything.

Each artifact should have a clear job and a clear owner:

• The outcome brief carries why this matters and what success looks like.

• The product spec carries what we’re committing to — scope, constraints, and trade-offs.

• The UX spec carries how the experience behaves — flows, states, and interactions.

• The technical spec carries implementation constraints — architecture, dependencies, and limits.

• The decision log carries what changed and who made the call.

• The dependency tracker carries what must line up before the outcome is real.

This is information architecture applied to how teams communicate — the same discipline we use to help users navigate products, pointed inward. The point isn’t more documentation. It’s hierarchy and ownership. The PRD should not become the container for every unresolved question in the organization.

Encode human judgment

Human oversight is not a meeting. It’s an accountable person making a clear judgment: Is this true enough? Is this useful enough? Is this coherent enough? Is this safe enough for the next team to consume?

AI makes human judgment more important, not less. The problem was never that humans were in the loop. The problem was that the loop was unclear.

Human judgment is not the slowdown. Lack of clarity is.

Make the judgment gates explicit, visible, and owned. A name next to a decision. A clear standard for what “ready” means. Not a committee — a person, accountable for a call.

---

The Close

The old operating model was designed for scarce production and comfortable buffers. Those constraints are gone. The model should change with them.

Design leaders have a choice. Wait for someone else to figure out how AI-speed work stays coherent — or step up and design the next operating model ourselves. The one that gets teams clear on what they’re building and why before the agents start running. The one that makes the work legible, accountable, and worth shipping.

I know which one I’m working on.

Stop defending the old process. Start designing what should be next.

---

Jason Cyr is VP and Head of Design for Cisco Security, AI and Platform.
He produces content about the intersection of design leadership and AI on Substack and YouTube.