Product Folks Should Ship Code: Webinar Recording + Playbook

A practical guide for PMs and designers to prototype and ship real code with AI—without becoming a menace to your engineering team.

Make AI do the mechanics—keep the judgment human.

Webinar video

Follow us on LinkedIn to get invited to our monthly webinars →

Follow our YouTube channel for past webinar recordings →

The big shift: product clarity becomes the constraint

When coding is cheap, the expensive part becomes:

• deciding what to build
• writing a coherent spec
• sequencing dependencies
• verifying each step

This is why you can ship a lot and still lose: speed without direction compounds waste.

Playbook move: treat discovery and shaping as a decision engine. Write down what you believe, what would change your mind, and what you'll do differently when it does.

The AI-native product flow (old vs. new)

The old way

1. Gather signals manually (calls, tickets, stakeholder opinions)
2. Roadmap priorities
3. Long shaping cycle + detailed PRD
4. Human engineers translate specs into code
5. QA + iteration

The AI-native way

1. Connect customer channels to AI (continuous signal extraction, with a platform like Evermuse)
2. Shape specs with AI (language matters more than ever), with the help of Evermuse
3. Submit to coding agents → working build quickly
4. Review, test, revise in tight loops
5. Engineers shift toward review + hardening, not translation

Playbook move: shorten the "spec → build → revise" loop. Keep human judgment on scope and tradeoffs.

Why product folks should ship code (the furniture builder analogy)

If you designed furniture but refused to learn wood and joinery, people would be suspicious. Historically, product folks could "get away with it" because code was too expensive to learn.

AI removes that excuse. Now, shipping code is a way to understand the product:

• how data flows
• how logic behaves
• what edge cases exist
• what's feasible without weeks of engineering time

Playbook move: don't become a full-time engineer. Become competent enough to prototype and ship small, safe changes—then partner with engineering for review.

Skill #1: Build better specs (language-first)

AI is language-based. Specs matter more than ever.

Principle: Start short, see what the model builds, then refine. A giant PRD upfront can lock you into bad assumptions. A short prompt plus iterative feedback often yields better ideas.

The 5Ws prompt framework

• Why: what problem are you solving, for whom, and why now?
• Where: where in the product does this live (screens, modules, routes)?
• What: what should happen (main behavior)?
• How: requirements, patterns to follow, libraries/components, constraints
• When: conditions, edge cases, exceptions

Playbook move: write prompts like you're briefing an expert coworker. Leave room for pushback.

From wireframes to interaction experiments

A useful mental model:

• early: interaction experiments (fast, not pixel-perfect)
• later: real code prototypes (often skipping heavy Figma work)

Prototype vs. production (simple rule)

When prototyping, explicitly tell the agent:

• "Prototype only"
• "Use mock data"
• "No backend changes"
• "Make it realistic enough to judge the UX"

Then iterate quickly until the experience feels right.

The 3 principles to ship real features (safely)

Eran's production pattern (works even if you don't "know code"):

1. Research the technical approach
   Ask the agent: best practices, libraries, similar implementations
2. Think through logical dependencies
   Many features depend on other primitives existing (data model, signals, permissions). Build in the right order, even if the "big payoff" feature is later.
3. Verification scales, planning doesn't
   Build step-by-step. Test each step. Commit working milestones. Avoid multi-day "pleasant coding" that collapses at the end.

Skill #2: Understand agents (so you don't fight them)

What is an agent?

An LLM running in a loop with tool use:

• edits files
• searches docs
• runs commands
• proposes plans
• iterates until the goal is reached

Two rules that prevent pain

1. Context windows are real
   Quality drops as threads get long ("the dumb zone"). Start a new thread earlier than you think (often ~40–50%).
2. Be "on the loop," not "in the loop"
   Let the agent run. Review at checkpoints (plan approval, PR review). Don't micromanage every token.

Tooling: move closer to code over time

A useful progression:

• Figma-adjacent tools (design-first)
• Lovable/Replit/v0 (easy app building, some code hidden)
• Cursor/Claude Code/Codex (production, full repo power)

Model is the engine; tool is the car. The tool determines: repo context, plan mode, permissions, debugging, and constraints.

Playbook move: start where you're comfortable, but aim to graduate to Cursor/Claude Code/Codex for production work.

Teamwork: how PMs ship without breaking engineering

McKinsey's finding (cited in the talk): PM+dev pairing ships faster. But the workflow matters.

A safe starter workflow (PM-first)

1. Write a clear spec using the 5Ws
2. Quick engineer consult (5 minutes): libraries, constraints, reuse existing functions
3. Run in Plan mode: get a detailed development plan
4. Engineer reviews the plan (10 minutes)
5. PM runs the plan with an agent and builds locally
6. Iterate until "good enough"
7. Commit to a new branch
8. Open a PR; engineer reviews, hardens, merges

Playbook move: engineers review + harden. PMs do the first pass build.

GitHub for product folks: 4 concepts that unlock everything

You don't need to memorize commands. You need the concepts.

1. Repository — all code for an app (plus history)
2. Commit — a milestone: a set of changes with intention
3. Branch — a safe parallel timeline for your work
4. Pull Request — a branch asking to be reviewed and merged

A PM-friendly "one sentence" workflow

"Please commit and push this to a new branch, create a PR, and drive all GitHub checks to green."

Agents can do the mechanics. You provide the judgment.

Q&A highlights (fast answers)

• What replaced Figma for mockups? Code prototypes + iterative prompts. Ask the agent for ideas to "bring it to life."
• Design system integration? Use component libraries (e.g., shadcn/ui) + a human QA pass to enforce consistency.
• How do I start in Claude Code? Clone your repo, ask for a plan, build something small, iterate.
• No codebase yet? Start in Lovable for quick prototypes; move to Cursor/Claude Code for anything you expect to move to production.

Want to learn more about AI coding?

• We're putting together small-group sessions where you'll actually build something from scratch with Claude Code and Cursor — guided, step by step. Minimal slides, mainly hands-on keyboard. Multiple future dates based on interest. If you're interested, just email zack@evermuse.com.
• If you're thinking "my whole product team needs this," we run 1-day, 2-day, and week-long workshops tailored to your team's stack and workflow. Everything from the webinar, but customized, hands-on, and built around your actual product: more info here.

About the speaker

Eran Dror is the Founder & CEO of Evermuse. He's helped 40+ startups find product-market fit and raise $300M+, including his first exit SetJam (sold to Motorola in 2012). He also runs Remake Ventures, a venture studio focused on human-centered startups.

Want to learn more?

• Follow Evermuse on LinkedIn for monthly webinars
• Subscribe to our YouTube channel for past webinar recordings
• Book a demo to see how Evermuse turns customer conversations into roadmap-ready decisions