For years, I didn’t write Product Requirements Documents.
Not because I didn’t know how. Not because I was lazy. But because sitting down to write a full PRD would slow everything down. I was a product manager who prided myself on being agile - I’d discuss the solution with stakeholders, maybe write an epic or two, then jump straight to writing tasks for engineers, design and UX. Most communication happened through conversations.
And it worked.
Until I started vibe-coding.
Then I realised that skipping the PRD wasn’t saving time - it was costing me money.
The Hidden Cost of “Just Start Coding”
Here’s what happens when you dive into Cursor, Bolt or Claude without a proper requirements document:
You brain-dump your idea into a prompt.
The AI generates something impressive.
You test it.
Then you realise it made assumptions - some brilliant (”Wow, where did you get those contact details for the footer?”), others... not so much.
So you prompt again.
And again.
You’re doing the requirements work anyway, just in the most expensive way possible - by iterating through working code instead of working through your thinking first.
You can’t expect to one-shot anything useful. And if you think you’re going to multi-shot your way to something worthwhile without a plan, I’ve got a bridge to sell you.
The AI tokens add up. The context window gets messy. You lose track of edge cases. And worst of all - you’re asking the AI to fill in blanks that should have been thought through before you wrote a single line of code.
The Conversation That Changed Everything
I’m now at the point where I don’t start a vibe-coding project without a PRD. Not because I’ve suddenly become a process zealot, but because I discovered a workflow that makes writing PRDs faster than not writing them.
Here’s how it works:
Step 1: The Brain Dump
I open a conversation with my AI du jour (usually in Claude, but any LLM works) and just... start talking about the project.
Here’s my actual first prompt from a project I’ve been working on for my sailing club:
“I am building a new website for my local sailing club and am part way through the process. There’s a public facing part to the site, that is accessible to everyone, that is mostly to market the site to new members. There is also a logged in part that is only available to members. The public part doesn’t change very much, except for the publishing of events and news (and perhaps occasional photos...tbd). The current members site is used to book onto training sessions and races, book meals, manage berthing of boats, etc. by the members, and that functionality is vital. But the new site needs to do a better job of keeping members up to date with what’s going on. There’s an active WhatsApp community, but I’d also like to include regular email functionality (using something like Brevo or Loops).
Can you help me flesh out a PRD that covers the functionality required by this sort of website, that I can use within Cursor? What are the sorts of things that I’ve forgotten?”
That’s it.
Not polished.
Not structured.
Just everything I knew about the project in one brain dump.
The key phrase: “What are the sorts of things that I’ve forgotten?”
This is the magic prompt. It shifts the AI from “documenting what you said” to “actively helping you think.”
Step 2: The Interview
The AI responds with a rough structure and starts asking questions. Not just surface-level stuff, but probing questions about:
Edge cases I haven’t thought through
User types I’ve glossed over
Technical decisions I’ve been avoiding
Design preferences I didn’t realize I had
Here’s a real example from a sailing club management system I built. After my initial brain dump, the AI asked:
“What happens when a junior member (under 18) tries to register? Can they register independently, or does a parent need to create their account? If a parent creates it, how do we link the accounts? Can one parent manage multiple junior accounts?”
I hadn’t thought about any of that. But the moment the AI asked, I knew the answer - parents had to register juniors, and we needed account linking. It was obvious in retrospect, but I would have discovered this three weeks into development without the PRD conversation.
Step 3: The Deep Dive
The AI keeps pushing. Question after question:
“For meal bookings, you mentioned weekly meals during racing season. How far in advance can members book? Is there a booking window (e.g., only see next week’s options) or can they book multiple weeks ahead? What happens if they book and then can’t make it?”
Again, I had knowledge and opinions about all of this. I just hadn’t articulated them yet. The AI was pulling details out of my head that I didn’t know were there.
“You want Stripe integration. At what points in the user journey do you need to collect payment? Membership registration? Event booking? Both? Do you need to handle refunds? What’s the refund policy?”
Every question revealed something I needed to decide. And deciding it NOW - in a document - was infinitely cheaper than discovering it when there’s already code built on wrong assumptions.
Step 4: The Refinement
After 15-20 minutes of back-and-forth, the AI has enough to generate a comprehensive first draft. We’re not done yet, now comes the refining:
“This section on berthing management needs more detail about boat types”
“Add a section on compliance and safeguarding - this is critical for junior members”
“The technical architecture needs to specify the database schema for linked accounts”
The AI updates the document in real-time. We iterate until it’s comprehensive.
What Makes This Different
The magic isn’t in the final document, it’s in the process.
By having the AI interrogate me, I’m forced to think through the entire solution:
How do I want it to behave?
What should happen in this particular edge case?
How should it look?
How should it be architected?
But equally important, I’m forced to identify what I don’t need to worry about:
“Choose whichever ORM makes the most sense”
“Use standard Tailwind components for now”
“We’ll figure out advanced reporting post-MVP”
The PRD becomes a forcing function for clarity. And clarity is what AI tools need to be effective.
The Payoff
Here’s what a 4,000-word PRD gets you when you start vibe-coding:
Better first prompts. Instead of “Build me a sailing club management system,” you can say “Implement the membership approval workflow described in section 3.2 of the PRD. Start with the database schema, then build the membership secretary dashboard.”
Fewer expensive iterations. The AI knows exactly what you want. It’s not guessing about edge cases because they’re already documented.
Clearer trade-offs. When the AI suggests something unexpected, you have a reference point. “That’s not what I wanted” becomes “That doesn’t match section 4.3, here’s what should happen instead.”
Better handoffs. When you need to bring in a designer or another developer (or even just future-you in three weeks), there’s a document explaining not just what to build, but why those decisions were made.
The Real Benefit: Your Thinking, Amplified
The best thing about this workflow isn’t the document - it’s what happens inside your head.
By having the AI ask probing questions, you’re essentially getting a free product consultant who:
Never gets tired
Remembers every detail you’ve mentioned
Asks about things you’ve forgotten
Challenges assumptions you didn’t realize you were making
It pulls out all your previous experience, all your instincts about how things should work, all your personal taste for getting things done. The stuff that’s valuable but usually stays locked in your head because writing it down feels tedious.
The AI makes it effortless to get that knowledge out and structured.
How to Actually Do This
Here’s the complete workflow I use:
1. Open a conversation and brain dump
Just start talking about your project. Don’t worry about structure or completeness. Tell the AI:
Then end with: “What are the sorts of things that I’ve forgotten? Interview me to get the details” or “Help me flesh out a complete PRD - what am I missing?”
This simple framing shifts the AI from documenting to actively helping you think.
2. Answer the questions that come back
The AI will start asking questions. Lots of them. Answer honestly:
When you know something, be specific
When you’re not sure, make a decision anyway (”Let’s say X for now”)
When you genuinely don’t know, say so and mark it as TBD
Don’t overthink it. The goal is to get your thinking out of your head and into a document.
3. Let the conversation flow naturally
You don’t need to be formal or structured. This is a conversation, not an interrogation. The AI will:
Ask follow-up questions based on your answers
Probe areas where you were vague
Surface edge cases you haven’t considered
Challenge assumptions you didn’t realize you were making
Let it push you. That’s where the value is.
4. Review the draft and iterate
Once you have a first draft, read through it. You’ll spot:
Gaps that need more detail
Sections that don’t match what you actually want
New things you’ve thought of while reading
Just tell the AI what to change. “This section needs more detail about X” or “Actually, I want Y to work differently.”
5. Mark the genuine unknowns
Don’t fake clarity you don’t have. If something legitimately needs input from others or depends on future decisions, mark it clearly:
“TBD - needs discussion with [person]”
“FUTURE - post-MVP enhancement”
“PENDING - depends on [other decision]”
This is incredibly valuable when you’re coding—you won’t waste time implementing something that might change.
A Real Example
I recently built a complete sailing club management platform. The PRD was over 4,000 words (!) covering everything from membership tiers to boat berthing, from payment processing to safeguarding compliance.
It included sections like:
Five distinct user personas with different needs
A complete membership approval workflow with state transitions
Detailed payment integration requirements across multiple booking types
Edge cases for junior member accounts and parental controls
Technical architecture decisions with clear reasoning
An 8-phase implementation plan with explicit priorities
Writing this “manually” would have taken days. With the AI conversation approach? About 90 minutes.
And when I opened Cursor to start building, every major decision was already made. I just had to implement.
The Counter-Intuitive Truth
Adding a PRD step to your vibe-coding workflow doesn’t slow you down - it’s what makes fast possible.
Because you’re not actually “adding” a step. You’re just doing the requirements work at the point where it’s cheapest:
Before you’ve written any code
Before you’ve established any patterns
Before you’ve made expensive assumptions
You’re going to do this thinking eventually. The question is whether you do it in a structured way upfront, or in an expensive, fragmented way while you’re debugging why the AI made weird choices about user permissions.
What This Means for Product Managers
If you’re a PM who codes (or wants to), this changes your workflow completely:
Old way:
Have hypothesis
Write it up carefully
Document requirements
Work with designers
Hand to developers
Wait 2 weeks
Test and learn
Iterate
New way:
Have hypothesis
Write PRD (90 minutes with AI)
Build prototype same day
Test with users next morning
Learn and iterate
The PRD isn’t extra overhead—it’s what makes the speed possible.
Start With Your Next Project
Next time you’re about to dive into building something, try this workflow, even if it’s a small feature. Open a conversation with an AI and just describe what you want naturally. End with:
“Can you help me flesh out a complete PRD? What are the sorts of things that I’ve forgotten?”
That’s it. No complex setup. No formal structure. Just describe what you’re building and ask what you’re missing.
Then let it push you. Answer honestly. Make decisions even when you’re not 100% sure.
You’ll be surprised how much you know that you didn’t realize you knew.
And when you start coding, you’ll be shocked at how much faster and cleaner it goes when the AI actually understands what you’re trying to build.
Next week: I’ll walk through the first steps in the vibe-coding process—how to take a PRD and setup your project using something like Bolt, Cursor or Claude. We’ll run through the steps before we actually start to build something and I’ll show you how to set yourself up for success.
Until then, try writing a PRD with AI and let me know how it goes. Hit reply - I read everything.
Subscribe now
Leave a comment