How AI Killed My PRDs (And Made Me a Better Product Manager)

About a year ago at vidiq, we started an experiment that made me nervous: product managers would also start coding. As a PM who knows how to code, I wasn’t worried about the technical side. I was worried about the split.

Would I get lost in the weeds of implementation? Would I spend all my time debugging instead of thinking about users? Would I constantly be making meta-decisions about what to build myself versus what to hand off to engineers?

I didn’t want product management to become an endless prioritization game of “what complexity do I solve myself?”

Then the Models Got Better

Fast.

At first, I was writing a decent amount of code myself. But within months, I was doing less and less. The AI models improved so rapidly that I could trust their output more, test less, and guide them less. They just… worked.

And as models got better at coding, something unexpected happened to my product process.

The PRD is Dead

I stopped writing PRDs entirely.

Not because I got lazy—because they became unnecessary friction. I went from idea → working POC in the same day. Sometimes the next day if it was complex and I was really iterating.

At first, these POCs lived in separate repos, hosted on Vercel for testing. Quick experiments. Throwaway code.

Then models got even better.

Now I’m going from thought → POC in the production repo within hours. Not a prototype. Not a proof-of-concept in isolation. A real feature, in the real codebase, ready for review.

An engineer looks it over, we do a few rounds of review iterations, and it ships the next week.

Velocity Went Way Up

The old world looked like this:

• “I want to run this test, but I need to compare it with another idea.”
• “I don’t have enough engineers. I don’t have enough time.”
• “I have to choose one.”

The new world looks like this:

• “I’ll build this tomorrow.”
• “An engineer can build that other thing next week.”
• “Boom, boom, boom, boom.”

We’re shipping multiple experiments simultaneously. Ideas that would have taken weeks of planning, scoping, and negotiation now take days.

But Here’s the Catch

Product management got harder.

When there’s zero friction between idea and working code, you’re tempted to build everything. Every fleeting thought. Every half-baked notion. Just ship it and see what happens, right?

Wrong.

That’s not product management. That’s just throwing shit at the wall and seeing what sticks.

The quality of your ideas matters way more now because there’s nothing stopping you from building bad ones. No PRD process to slow you down. No lengthy eng discussions to reality-check your thinking. Just you and a model that will happily build whatever you ask.

User Empathy is Non-Negotiable

I care deeply about this: even in a test, I want users to have a good experience. I don’t want someone stuck in a bad variant just because we could ship faster.

If they’re in the experiment, they should still feel like the product respects their time. They shouldn’t suffer through something half-baked just because “what other choice do they have?” (Sure, they can churn. That’s a terrible outcome.)

This is where a lot of teams will fail in the AI-assisted product era. Speed is seductive. Shipping is addictive. But bad ideas shipped fast are still bad ideas.

My New Workflow: AI as a Sparring Partner

PRDs forced you to think deeply because writing was slow. Now you don’t get that natural brake.

So I built a new one.

Instead of jumping straight into code, I spend significant time with Claude Opus 4.6 doing a back-and-forth technical evaluation. This isn’t just a prompt. It’s a debate.

I start with a rough spec—what I want to build, why, and how I think it should work. Then I use the model to:

• Think through edge cases
• Challenge my assumptions
• Call me out when I’m lacking user empathy
• Debate whether the idea is actually good

My OpenClaw setup is connected to our Notion workspace, which has documentation on every test we’ve ever run. So the AI has context. It knows what we’ve tried before. It can reference past experiments and say, “We tried something similar in Q3—have you considered how this is different?”

You need a good model for this. Not GPT-4o that says “wow, great idea!” to everything. You need Opus 4.6. Something that will actually push back.

This process creates a mini-PRD embedded in the technical documentation. By the time I start building, I’ve already thought it through deeply—but in a conversation, not a Word doc.

Intuition Still Matters

I’m not outsourcing my judgment to AI. I’m augmenting it.

I watch session recordings every day. I look at analytics data constantly. Over time, that builds intuition. You start to feel when something is off, even if the data doesn’t scream it yet.

So the workflow is:

1. Intuition from watching users + data immersion
2. AI debate to stress-test the idea
3. Real user empathy to ensure it’s not just clever, but actually helpful

That combination is what makes the decisions better.

Reviews Changed Too

In the old world, I’d present a PRD. Text. Maybe some wireframes. Abstract.

Now I show up with a working POC. My CEO and head of product can click through it. They can feel the interaction. They can imagine themselves as the user.

That tactile experience unlocks better feedback. They’re not trying to imagine how it might work—they’re using it. Their intuition and user empathy kick in immediately.

“This feels clunky here."
"Oh, I love this part."
"What if we tweaked this?”

Better feedback → better product.

The Paradox

Here’s the kicker:

Decision-making became tougher, but decisions became better.

I have to think harder about whether an idea is worth building. I have to debate with AI, reason through edge cases, and constantly gut-check for user empathy. I can’t hide behind “we don’t have time” or “engineering is too busy.”

But because I’m forced to think deeper, the ideas that do ship are higher quality. And because AI eliminates the implementation bottleneck, those high-quality ideas reach users in days instead of months.

What This Means for Product Management

If you’re a PM who can’t code, you’re not obsolete. But you need to adapt.

The value of a PM is no longer in being the “ideas person” who writes specs for engineers to implement. Engineers have AI now too. They can move fast.

Your value is in judgment. Knowing which ideas matter. Understanding users deeply. Prioritizing ruthlessly. Ensuring empathy doesn’t get sacrificed for velocity.

The friction is gone. The velocity is here. But that just means the bar is higher.

You need to be better at thinking. Better at debating. Better at caring.

Because if you’re not, you’ll just be shipping fast—and shipping badly.