"Sam, how do I stay relevant as a PM when AI can write PRDs, generate designs, and even code prototypes?"
I hear this question at least once a week from the PMs I mentor on MentorCruise.
My answer surprises them:
"You're asking the wrong question. AI doesn't replace PMs—it multiplies the ones who learn to compress discovery."
Then I show them the Turing case study. The one where we compressed 6 weeks of discovery down to 1 week using AI-powered prototyping. Where engineering stopped wasting weeks building the wrong thing because we validated ideas BEFORE a single line of production code was written.
After walking through the workflow, their eyes light up. This isn't about AI replacing PMs. It's about PMs who master AI-powered discovery becoming 4x force multipliers.
This article breaks down:
The exact AI discovery workflow I teach my mentees (Crawl → Walk → Run framework)
How to compress discovery from 6 weeks to 1 week (Turing case study)
The 5-tool stack that generates working prototypes in hours, not weeks
Your 4-week path to mastering prototype-driven discovery
What separates AI-fluent PMs from those stuck in the old paradigm
If you're a PM who wants to level up your AI product management skills—or you're wondering how to build this capability in your own practice—this is the playbook I use with every mentee who asks.
---
Here's what I've observed mentoring 30+ product managers over the past three months:
The teams that succeed with AI aren't using it to write faster. They're using it to discover better.
The teams that struggle are stuck in what I call "Copy/Paste AI"—they use ChatGPT for brainstorming, paste outputs into docs, and call it "AI adoption."
But they're still discovering problems AFTER engineering starts building. They're still wasting weeks on rework because "we built the wrong thing."
The breakthrough insight I teach every mentee:
AI's biggest value isn't automating documentation. It's compressing discovery—validating ideas with working prototypes BEFORE you waste engineering cycles.
This is the skill gap. And it's exactly what I help PMs close in our mentorship sessions.
---
I've mapped three distinct maturity stages based on the patterns I see across teams. Most PMs I mentor are stuck at Stage 1 (Crawl) when they first reach out. By the end of our work together, they're operating at Stage 2 (Walk) and planning for Stage 3 (Run).
What it looks like:
Limitation: You're still the integration layer. No working prototype. Engineers still start blind.
Common mentee frustration: "I'm using AI, but I'm still wasting weeks discovering we built the wrong thing. What am I missing?"
What they're missing: Working prototypes that validate ideas BEFORE engineering starts.
What it looks like:
Discovery compression: 6 weeks → 1 week
Limitation: Still manual handoffs between tools
The game-changer: You now validate ideas with functional prototypes BEFORE engineering writes production code. No more "Week 3 of development, we realize the flows don't work" surprises.
This is exactly what I led at Turing. And it's the workflow I teach every mentee who wants to master AI-powered discovery.
One mentee recently told me: "I showed my stakeholders a working prototype in our first meeting. They immediately spotted the flow problem we would've spent two weeks building wrong. This just saved my team a sprint."
What it looks like:
PM has conversation with AI agent Agent automatically orchestrates the entire workflow: .
Discovery compression: 6 weeks → 1 week (fully automated)
Breakthrough: Agent manages discovery-to-handoff autonomously
This is what I'm building: the Agentic AI PM Co-Pilot. It's not ready yet, but the PMs who master Walk stage today will be first to adopt Run stage workflows tomorrow.
For mentees: Our focus is getting you fluent at Walk stage—that's where the immediate impact lives.
---
When I joined Turing, the product team had a familiar problem:
"We spend 6 weeks on discovery and design. Engineering starts building. Week 3, we realize the flows don't work. Back to the drawing board."
Sound familiar? It's the #1 pain point I hear from mentees.
Here's what we did to fix it:
Discovery & Planning - 6 weeks:
Development - 4 weeks:
Rework - 2 weeks:
2+ cycles of rebuilding
Weeks of engineering effort wasted
Total: 14 weeks (6 weeks wasted on misalignment and rework)
We implemented a 5-step workflow that validates ideas with working prototypes BEFORE engineering starts:
Step 1: Voice & Transcript
Meeting transcripts captured automatically
AI extracts key decisions and requirements
No manual note-taking
Step 2: AI PRD Generation
ChatGPT synthesizes insights into structured PRD
30 minutes vs weeks of writing
PM guides and edits, doesn't write from scratch
Step 3: Design Variant Generation
Magic Patterns creates 3-5 UI approaches from PRD
Stakeholders see options immediately
Designer refines selected variant
Step 4: Functional Prototype (THE BREAKTHROUGH)
Replit builds working prototype in 2 hours
Not static mockups—clickable, functional UI
Stakeholders interact with real software
Discover what works/doesn't work BEFORE engineering
Iterate on prototype until it's right
Step 5: Production Handoff
AI generates detailed JIRA tickets from validated prototype
Engineers receive working prototype + detailed spec
They build what's already been validated with customers
The Results:
Discovery compressed from 6 weeks → 1 week
One of my designers said it perfectly: "Having the PM just show me the prototype saved two weeks of back-and-forth. I understood the problem immediately and could jump straight to production-ready design."
Engineering focused on production implementation, not discovering what doesn't work.
This is the exact workflow I teach in my mentorship sessions.
---
Here's the counter-intuitive insight I share with every mentee who worries about AI replacing PM work:
At Turing, we're writing MORE PRDs, not fewer.
When I mention this in mentorship sessions, mentees are confused. "Wait, I thought AI replaces documentation?"
No. The PRD is now fuel for AI prototype generation, not documentation for humans to read.
Old paradigm:
PM writes PRD for engineers to read
Engineers don't read it (too long, outdated, no time)
Start building, discover gaps, ask questions
Weeks lost to misalignment and rework
New paradigm:
AI writes PRD from PM conversation (30 minutes)
PRD feeds AI to generate working prototype
Prototype validates the PRD (discover gaps immediately)
Iterate on prototype until right
Engineers build from validated prototype + iterated spec
One Turing PM joked: "Our PRDs are write-only. We generate them, AI consumes them to build prototypes, and nobody opens the document. But everything ships aligned because engineers have working prototypes."
For mentees, this reframes the value question:
Your value as a PM isn't writing docs. It's orchestrating discovery—knowing what questions to ask, what problems to validate, what trade-offs to make.
AI handles the artifact generation. You handle the strategic thinking.
---
In our mentorship sessions, I walk PMs through the exact tool stack that enables Walk-stage discovery compression:
1. ChatGPT-4 (Requirements Layer)
What it does: Generates PRDs from conversations
How I teach it:
Custom GPTs for your company's PRD format
Prompt: "Generate a PRD from these meeting notes in [format]"
Pro tip: Ask ChatGPT to write better prompts for you
Mentee skill: Conversation-to-requirements translation
2. Magic Patterns (Design Layer)
What it does: Creates 3-5 UI variants from PRD text
How I teach it:
Input: PRD or text description
Output: Design options to validate with stakeholders
Designer refines, doesn't create from scratch
Mentee skill: Fast design iteration before prototype
3. Replit (Prototype Layer - THE KEY)
What it does: Builds functional prototypes in hours
How I teach it:
Input: PRD + selected design variant
Output: Working prototype with clickable UI
This is where discovery compression happens
Stakeholders interact with real software
Iterate until validated
Mentee skill: Prototype-driven validation (not documentation-driven)
This is the breakthrough tool. Every mentee I work with learns to prototype with Replit.
4. JIRA (Production Handoff Layer)
What it does: Generates production tickets from validated prototype
How I teach it:
ChatGPT generates tickets from prototype:
User story format
Acceptance criteria
Story point estimates
Dependencies
Engineers receive clear spec + working reference
Mentee skill: Validated prototype → production handoff
5. Google Docs (Documentation Layer)
What it does: AI-generated spec that updates as prototype evolves
How I teach it:
ChatGPT generates spec in Docs format
Updates as prototype iterates
Engineers can reference if needed (prototype is truth)
Mentee skill: Documentation as byproduct, not primary artifact
The missing piece: These tools don't talk to each other. YOU manually trigger each step.
That's the Walk→Run gap. That's what the Agentic AI PM Co-Pilot will automate.
But for now, Walk stage is where you compress discovery and avoid wasted engineering effort.
---
When a mentee joins my program wanting to level up their AI PM skills, here's the 4-week path we follow:
Week 1: Start with Prototype Generation
Focus: Get from idea to working prototype
Tools: ChatGPT (PRD) → Replit (prototype)
Exercise: Pick ONE simple feature to prototype
Goal: See working UI in hours, not weeks
Mentorship focus:
How to write prompts that generate good PRDs
How to translate PRD → working prototype
What makes a good validation prototype vs production code
Mentee outcome: "I just showed my stakeholders a working prototype in 2 hours. They're blown away."
Week 2: Add Design Iteration
Focus: Validate design before prototype
Tools: Magic Patterns for design variants
Exercise: Idea → PRD → 3 design options → prototype
Goal: Validate design with stakeholders before engineering
Mentorship focus:
How to generate design variants from text
How to facilitate stakeholder feedback on options
When to iterate design vs prototype
Mentee outcome: "Stakeholders picked the third design variant. Would've spent a week building the first one wrong."
Week 3: Add Production Handoff
Focus: From validated prototype to engineering tickets
Tools: JIRA ticket generation from prototype
Exercise: Full workflow ending with working prototype + detailed tickets
Goal: Hand off to engineering with validated prototype
Mentorship focus:
How to generate production-ready JIRA tickets from prototypes
How to communicate validated prototype to engineering
Managing stakeholder expectations vs engineering constraints
Mentee outcome: "Engineering said this is the clearest handoff they've ever received. No questions, just building."
Week 4: Measure Discovery Compression
Focus: Prove the value to leadership
Exercise: Document metrics and build the case
Goal: Show discovery time reduction + rework elimination
Metrics we track:
How long did discovery take? (baseline vs new)
How many engineering rework cycles? (before vs after)
Stakeholder alignment time (meetings saved)
Mentorship focus:
How to quantify discovery compression
How to communicate ROI to leadership
Building the case for AI-powered workflows
Mentee outcome: "I showed my VP we compressed 4 weeks of discovery into 3 days. They want me to teach the whole team."
Month 2-3: Build Team Fluency
Focus: Apply to 5-7 more features
Goal: Build muscle memory, refine prompts, teach others
Mentorship focus:
Expanding from individual to team adoption
Training other PMs on the workflow
Building internal best practices
Month 4+: Prepare for Run Stage
Focus: Document what's still manual, prepare for agent workflows
Goal: Ready for Agentic AI PM Co-Pilot when available
This is the progression I take every mentee through.
By month 2, they're compressing discovery on every feature. By month 3, they're teaching their team.
---
After mentoring 30+ product managers through this transformation, I've identified the key mindset shifts:
Old PM Mindset: Documentation-Driven
"I need to write the perfect PRD"
"More detail = better handoff"
"Engineers will read this and build it right"
Result: Weeks writing docs nobody reads, discover problems after building starts
New PM Mindset: Prototype-Driven
"I need to validate this idea with a working prototype"
"Iterate on prototype until stakeholders confirm it's right"
"Engineers build from validated prototype + spec"
Result: Discover problems when fixing them is cheap (prototype stage), not expensive (production code stage)
The Shift I Help Mentees Make:
From: "How do I write better docs?"
To: "How do I validate faster with working prototypes?"
From: "AI will replace PMs"
To: "AI multiplies PMs who learn to compress discovery"
From: "Waiting for perfect tools"
To: "Using today's tools to deliver immediate value"
The PMs who make this shift become 4x force multipliers.
The ones who don't become bottlenecks.
---
I'm building this because I'm tired of being the integration layer between tools—and because I want every PM to access Walk-stage capabilities without needing a mentor.
The vision:
You say: "I need a prototype for a user interview scoring system."
The agent:
Asks clarifying questions (async, via voice or text)
Generates structured requirements (pulls from your past work)
Creates 3 design variants (using your design system)
Builds functional prototype (deployed URL you can share)
Manages iteration cycles (stakeholder feedback → updated prototype)
Generates production-ready JIRA tickets (from validated prototype)
Manages handoff to engineering (working prototype + detailed spec)
You review at each stage. The agent does the execution.
The breakthrough: Full discovery-to-handoff automation with context memory.
The agent knows:
Your company's PRD format
Your design system
Your JIRA workflow
Your stakeholder preferences
What worked last time
Target: Same 6-week → 1-week discovery compression, fully automated.
For mentees: This will democratize what I currently teach 1:1. But mastering Walk stage today prepares you to adopt Run stage tomorrow.
---
If you're a PM who wants to level up your AI product management skills, here's how we work together:
What We Cover in Our Sessions:
Month 1: Discovery Compression Foundations
Crawl → Walk transition (your specific context)
Tool stack setup (ChatGPT, Magic Patterns, Replit, JIRA)
First prototype walkthrough (live coaching)
Stakeholder management strategies
Month 2: Building Team Fluency
Applying workflow to 5-7 features
Measuring and communicating ROI
Teaching others on your team
Handling edge cases and failures
Month 3: Strategic AI Adoption
Building internal best practices
Preparing for Run stage (agent workflows)
Career positioning as AI-fluent PM
Contributing to industry knowledge
Find out if MentorCruise is a good fit for you – fast, free, and no pressure.
Tell us about your goals
See how mentorship compares to other options
Preview your first month
