How Mentors Can Help Teams Escape the Build Trap: A Guide to Prototype-Driven Discovery
Discover how AI-powered prototypes are helping product teams compress discovery from 6 weeks to 1 week, avoiding costly engineering rework. Sam Ho, Head of Product at Turing, shares his three-stage maturity framework and actionable 4-week playbook for mentors guiding teams away from the "build trap" toward validated, prototype-driven development.
Welcome to another edition of Mentor Insights on mentor.sh – where experienced professionals share their expertise to help accelerate your career growth. Today, we're exploring how mentors can guide product teams away from the costly "build trap" using AI-enabled prototype-driven discovery.
Our featured mentor, Sam Ho, Head of Product & Design at Turing (with experience at Google, Intel, Glassdoor, and more), shares his framework for helping teams compress discovery from weeks to days and avoid wasted engineering effort. Whether you're a product leader, aspiring PM, or mentor yourself, this guide provides actionable strategies for transforming how teams validate ideas before committing to production.
The Costly Pattern Mentors See Every Day
As mentors, we've all watched talented teams make the same painful mistake: spending weeks building features perfectly—only to discover they built the wrong thing.
Recently, I mentored a product team that spent two weeks on a feature. Clean code. Well-tested. Shipped on time. Then the PM realized the core user flow didn't work. Two weeks of engineering effort, gone. The problem wasn't execution—it was that discovery happened too late.
This pattern is everywhere. Teams spend 6 weeks on discovery and design. Engineering starts building. By week 3, they realize the flows don't work. Back to the drawing board. As Melissa Perri describes in her work on the "build trap," teams optimize for output (features shipped) instead of outcomes (problems solved).
The breakthrough insight: The most effective teams I mentor have stopped using engineering cycles to discover what doesn't work. Instead, they've compressed 6 weeks of iteration down to 1 week using AI to generate working prototypes in hours, not weeks. They validate with stakeholders before a single line of production code gets written.
Why Traditional Discovery Fails Teams
Let me show you the traditional model most teams still follow:
Week 1-3: PM writes PRD, Designer creates mockups, Alignment meetings
Week 4: Engineering starts building iteratively
Week 5: First working version → PM realizes flow doesn't work
Week 6-7: Back-and-forth on fixes (communication latency)
Week 8: Ship something → User feedback confirms original concerns
Week 9-10: Engineering backlog fills with fixes, but iteration is too slow
The core problem: Teams discover issues after production code is written. Communication overhead and engineering backlog make fixes expensive and slow. Design decisions get hardcoded in ways that are difficult to fix.
As a mentor, here's what I tell teams: You're not struggling with slow engineering. You're struggling with slow discovery—and discovering problems only after engineering has already started.
The AI-Enabled Discovery Model That's Changing Everything
The teams that have solved this problem follow a radically different model:
Day 1: PM conversation → AI generates working prototype
Day 2-3: Stakeholders interact with functional software (discover flow issues immediately)
Day 4-5: Iterate on prototype (fast, no engineering backlog)
Week 2: Validated prototype + detailed spec → Hand off to engineering
Engineering builds what's already been validated with users. When you launch, feedback is refinement, not "we built the wrong thing."
The breakthrough: Discover and fix issues when iteration is cheap (prototype stage), not expensive (production code stage).
This aligns with what Marty Cagan and Chris Jones at SVPG wrote about continuous discovery—except now AI enables you to compress weeks of iteration into days through instant prototyping.
The Three Maturity Stages: Crawl → Walk → Run
After mentoring 30+ product teams experimenting with AI, I've mapped three distinct maturity stages. Understanding where your team sits helps you know what to focus on next.
Stage 1: Crawl - Copy/Paste AI
What it looks like:
- PM opens ChatGPT, asks for PRD outline
- Copies output into Google Doc
- Asks for JIRA ticket format
- Copies output into JIRA
- Repeats for every artifact
Discovery compression: Minimal (maybe 1-2 days saved on writing)
The bottleneck: You're still doing all the translation work. AI generates text, but YOU copy/paste between tools, YOU format for each system, YOU maintain consistency. Critically: You still don't have a working prototype. Engineers still start blind.
Every team I mentor is doing this. It's better than nothing, but it doesn't compress discovery.
Stage 2: Walk - AI-Generated Artifacts → Tool Import
What it looks like:
- ChatGPT generates PRD → exports to Google Docs
- ChatGPT generates designs → imports to Magic Patterns
- AI generates working prototype → deploys on Replit
- AI generates JIRA tickets → bulk imports to JIRA
Discovery compression: 6 weeks → 1 week
The breakthrough: You're no longer formatting manually. AI knows each tool's format and generates ready-to-import artifacts.
But more importantly: You now have a working prototype in hours, not weeks.
This addresses what Julie Zhuo calls the "build trap"—building things before validating them. With AI prototyping, validation comes first, building comes second.
Key advantage: Works with your existing systems. You don't need AI-native code infrastructure. Keep using Jira, Linear, GitHub—whatever you have today. The prototype validates the direction, then your existing engineering workflow takes over.
Stage 3: Run - Agentic AI PM Co-Pilot
What it looks like:
- PM has conversation with AI agent
- Agent automatically generates requirements, creates design variants, builds prototype, iterates based on feedback, generates production-ready JIRA tickets, and manages handoff to engineering
Discovery compression: 6 weeks → 1 week (fully automated)
The future: Agent manages the entire discovery-to-handoff workflow. While this stage is still emerging, Walk stage is the sweet spot right now—accessible to any team, works with existing systems, delivers immediate discovery compression.
Actionable Mentoring Insights: The 4-Week Adoption Playbook
As a mentor, here's what I recommend to teams ready to compress discovery and avoid wasted engineering effort. No infrastructure changes needed. Keep your existing Jira, Linear, GitHub workflows.
Week 1: Start with Prototype Generation
Focus: Get from idea to working prototype
- Tool: ChatGPT (PRD) → Replit (prototype)
- Pick ONE simple feature to prototype
- Goal: See working UI in hours, not weeks
As Gibson Biddle writes, the best product strategy is one you can test quickly—prototyping is how you test strategy, not just features.
Week 2: Add Design Iteration
Add: Magic Patterns for design variants
- Workflow: Idea → PRD → 3 design options → prototype
- Test with real stakeholder feedback
- Goal: Validate design before engineering
Week 3: Add Production Handoff
Add: JIRA ticket generation from validated prototype
- Workflow ends with: Working prototype + detailed tickets
- Hand off to engineering team
- Goal: Engineers build from validated prototype
Week 4: Measure Discovery Compression
- Track: How long did discovery take? (should be days, not weeks)
- Track: How many engineering rework cycles? (should be near zero)
- Document what worked
- Goal: Prove discovery compression to leadership
Month 2: Apply workflow to 3-5 more features and build team muscle memory.
Months 3-6: Discovery compressed for most features. Engineering building right things first time.
A Real-World Case Study
Let me share a case study from a team implementing this workflow at Turing.
The Traditional Process (14 weeks total):
- Discovery & Planning - 6 weeks: User interviews → mockups → feedback cycles → alignment meetings on static mockups → No working prototype to validate ideas
- Development Phase - 4 weeks: Engineers build from PRD + static mockups → Discover gaps → Build something, realize it doesn't work → Rework cycles consume time
- Testing/UAT - 2 weeks: QA finds issues with core flows → "This isn't what we meant"
- Rework - 2 weeks: 2 cycles of rebuilding → Weeks of engineering effort wasted
The AI-Enabled Solution (8 weeks total):
They implemented a 5-step workflow that compresses discovery and validates BEFORE engineering starts:
-
Voice & Transcript: Meeting transcripts captured automatically → AI extracts key decisions and requirements
-
AI PRD Generation: ChatGPT synthesizes insights into structured PRD → 30 minutes vs weeks of writing
-
Design Variant Generation: Magic Patterns creates 3-5 UI approaches from PRD → Stakeholders see options immediately
-
Functional Prototype (The Game-Changer): 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
-
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 & Validation - 1 week: Compress 6 weeks → 1 week
- Development Phase - Faster & Cleaner: Engineers build from validated prototype → No "wait, this doesn't work" surprises → Build the right thing, first time
One designer on the team captured it perfectly: "Having the PM just show me the prototype he built saved two weeks of back-and-forth. I understood the problem immediately and could jump straight to production-ready design."
Key Mentoring Principles for Teams Adopting AI Discovery
As you guide teams through this transformation, keep these principles front and center:
1. Don't Wait for Engineering to Adopt AI
The most common blocker: "We're exploring AI for our engineering workflows, but there's change management, prerequisites, codebase architecture changes. It'll take months."
What teams miss: You don't need to wait. While AI-enabled engineering has prerequisites, AI-enabled discovery doesn't. You can start prototyping today. No engineering involvement needed.
Both can improve in parallel. But as a PM, you're not blocked. You can improve discovery immediately while engineering figures out their AI adoption path.
2. PRDs Aren't Dead (But Reading Them Is)
Here's the counter-intuitive insight: Teams using AI-enabled discovery are writing MORE PRDs, not fewer.
The difference? 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
New paradigm: AI writes PRD from PM conversation → 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
As Itamar Gilad warns in his work on AI-generated artifacts, the risk isn't using AI—it's using AI without thinking. The prototype-driven approach addresses this by using AI to enable faster validation, not replace thinking.
3. Start Where You Are
You don't need perfect tools or complete buy-in. Pick ONE feature. Open ChatGPT. Generate a PRD. Open Replit. Build a working prototype. Share with stakeholders. Get feedback on working software. Iterate until validated. THEN hand off to engineering.
If you compress discovery on that ONE feature, do it again for the next. Do this 5-7 times, and you're at Walk stage. That's where discovery compression happens. That's where you avoid wasted engineering effort.
The 5 AI Tools to Recommend (Walk Stage)
If your mentees want to compress discovery today, here's the exact stack to recommend:
1. ChatGPT-4 (Requirements Layer)
- Custom GPTs for PRD generation from conversations
- Pro tip: Ask ChatGPT to write better prompts for you
2. Magic Patterns (Design Layer)
- Input: PRD or text description
- Output: 3-5 UI variants with different approaches
- Designers refine, don't create from scratch
3. Replit (Prototype Layer - THE KEY)
- Input: PRD + selected design variant
- Output: Functional prototype with working UI in 2 hours
- This is where discovery compression happens
- Stakeholders interact with real software
As Teresa Torres has written extensively about continuous discovery habits—Replit makes her weekly customer touchpoints possible by giving you working prototypes to test, not static wireframes.
4. JIRA (Production Handoff Layer)
- ChatGPT generates tickets from validated prototype
- Engineers receive clear spec + working reference
- No more "wait, what did you mean?" cycles
5. Google Docs (Documentation Layer)
- ChatGPT generates spec in Docs format
- Updates as prototype evolves
- Engineers can reference if needed (but prototype is truth)
Looking Forward: Your Next Move as a Mentor
The teams compressing discovery aren't waiting for perfect tools. They're building working prototypes TODAY with ChatGPT + Replit.
The teams wasting engineering effort are still writing docs and hoping for the best.
Don't let your mentees be the second group.
Important caveat from Itamar Gilad: Beware of AI accelerating feature factories—producing more junk features faster. The antidote: use AI for discovery compression (validate ideas faster), not just execution acceleration (ship more features).
The question for you as a mentor: How will you help your teams compress discovery now—or will they keep wasting engineering cycles?
Further Reading & Attribution
This article was inspired by and adapted from Sam Ho's excellent Substack post: "The PM's Guide to Building the Right Thing: Prototype-Driven Discovery". Sam's detailed case study from Turing and his framework for the three maturity stages (Crawl → Walk → Run) provide invaluable insights for any team looking to compress discovery and avoid wasted engineering effort.
Additional thought leaders referenced:
- Melissa Perri on the "build trap" and product thinking
- Marty Cagan and Chris Jones (SVPG) on continuous discovery
- Julie Zhuo on avoiding the build trap
- Gibson Biddle on testable product strategy
- Teresa Torres on continuous discovery habits
- Itamar Gilad on AI-generated artifacts and product management
About the Author
Samuel W (Sam) Ho is Head of Product & Design at Turing (a Series D startup focused on accelerating AGI advancement and deployment), bringing experience from Google, Intel, Glassdoor, Kenshoo, and Sendoso.
Having had many varied roles on his path to product management (engineering, sales, marketing, co-founder), Sam was fortunate to have great mentors and coaches guide his journey. From early CTOs/GMs at Intel who advised him to understand marketing and sales beyond engineering, to learning about management and leadership while running a startup, Sam has leveraged these learnings to scale product processes effectively at different stages of companies.
Sam is deeply focused on coaching mentality with all his direct reports. As one Group PM noted: "Sam's expertise in product runs deep... Whether it be suggesting a fresh approach, introducing a new framework, or challenging the convention, our team was consistently evolving. It's not an exaggeration when I say I learned something new in every meeting with him."
Connect with Sam on mentor.sh to learn more about AI-driven product leadership, team coaching, and prototype-driven discovery strategies.
About mentor.sh
mentor.sh is the premier platform connecting ambitious professionals with industry experts for personalized mentorship. Whether you're looking to advance your career, transition into product management, or scale your startup, our curated network of mentors provides the guidance you need.
Explore More Resources:
- Browse mentors from leading tech companies like Turing
- Discover our comprehensive Content Hub for more insights
- Join our interactive Group Sessions for collaborative learning
- Submit your own insights through our Marketing Hub
Ready to accelerate your career? Find your perfect mentor today at mentor.sh.