Building & Designing Products in the Age of AI: Webinar Recording + Playbook

In this live conversation, Evermuse founder Eran Dror and Design Sprint creator Jake Knapp explore what changes when software becomes trivially easy to build: where craft moves, why empathy becomes a competitive advantage, and how product teams can stay customer-anchored while shipping at AI speed.

Make the mechanics automatic - 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 →

TL;DR

AI makes building cheaper and faster - but it doesn't make knowing what to build any easier.
The "new scarce resource" is customer understanding (and the team habits that keep you anchored in it).
Product craft isn't dead; it's moving closer to the medium (i.e., code, components, systems, and behavior).
Designers, PMs, and engineers are converging into "makers" - taste + speed + execution, in one loop.
The best AI products will feel like magic: they remove work you shouldn't have to do (not just speed up work you already do).

The new bottleneck: when code is cheap, direction is scarce

Eran opens with a tension you're probably already feeling: engineering time is no longer the constraint. When AI makes development faster, the backlog disappears faster too - and the bottleneck shifts to a higher-level problem:

Do we actually understand what customers need?
Are we building the right thing next?
Can we learn faster than we ship?

The trap is obvious: if you don't stay close to customers, you can ship a lot of very polished irrelevance. But if your discovery cycle takes months while competitors iterate in days, you can lose momentum even if your research is "better."

Playbook move: treat discovery as a decision problem (not a research project). For every idea, write down:

what you believe today,
what evidence would change your mind,
and what decision you'll make differently if it does.

The Celebrimbor problem: borrowed superpowers, unclear consequences

Eran's Tolkien metaphor sets the tone: collaborating with AI can feel like collaborating with a powerful partner whose long-term incentives you can't fully see.

It's joyful because it expands capability - suddenly you can:

prototype "impossible" ideas,
rebuild workflows you hate,
and ship features at speeds that used to require teams.

But it also raises real questions:

Are we trading away security or control for speed?
Are we creating software so quickly that it becomes impossible to maintain, differentiate, or monetize?
Are we losing the human judgment that makes products work?

Playbook move: embrace the leverage - but add friction to decisions, not to execution. Let AI accelerate building, but keep your team accountable for choosing.

Craft isn't dead - it moved closer to the medium (i.e., code)

A recurring theme: craft still matters, but the "craft surface" is changing.

In an AI-native workflow, the first version of a UI may be generated without touching Figma. That doesn't mean design is irrelevant; it means the craft shifts to:

components and systems (consistency),
performance and behavior (speed, transitions, edge cases),
and the narrative and intent behind the experience (what the product is really doing for the user).

Eran's practical take: if you care about the experience, you eventually have to get closer to code—because software is the medium.

Playbook move: stop treating "design" as a deliverable and start treating it as an input to the build loop. Your job is to keep taste, coherence, and user intent alive while speed increases.

Designers + PMs + Engineers converge into makers

Jake and Eran describe a world where silos blur:

engineers can produce decent UI quickly,
designers can influence implementation directly,
and PMs can translate "requirements" into staged prompts that guide the build.

That convergence creates a new expectation: more people will push the product forward through the same medium (code + prompts).

Playbook move: re-skill around the new shared interface:

prompt writing as "fast requirements,"
lightweight system thinking (components, constraints),
and continuous feedback from real users - just build it and let them try it.

Empathy is the moat: understanding customers better than anyone

When execution gets commoditized, the differentiator becomes what you choose to execute.

Jake brings it back to a principle that survives tech cycles: empathy—the discipline of understanding what customers actually want, need, and struggle with.

You can ship faster, but speed doesn't substitute for insight. In fact, speed makes insight more valuable, because mistakes compound faster too.

Playbook move: make empathy operational:

make customer signals easy to access,
repeat synthesis on a cadence,
and bake user voice into roadmap decisions (not as anecdotes, as evidence).

From AI tools → AI magic: remove work users shouldn't have to do

A useful distinction emerges in the second half: AI products tend to fall into two buckets:

Tools: they help you do the same work faster (e.g., in voice-of-customer work: tagging transcripts, summarizing notes, classifying feedback).
Magic: they change the workflow so you don't have to do the work at all.

The "magic" vision isn't "read email faster." It's "most email should never reach you."

Playbook move: define your "magic outcome":

What work is your customer doing today that shouldn't exist?
What decisions are they trying to make?
What would it feel like if the product delivered the outcome (not just another input)?

Where Evermuse fits: always-on customer intelligence for fast builders

Eran frames Evermuse as an "AI intelligence agency" for teams shipping quickly: continuously distilling signals from sales calls, support calls/chats, product interviews, and other sources - then making that intelligence usable inside the places teams already work.

The strategy is consistent with the overall theme of the webinar:

automate mechanics (capture, organize, synthesize),
protect judgment (prioritize, decide, trade off).

Playbook move: whether you use Evermuse or not, the operating principle holds: make customer intelligence continuous (not quarterly) and shared (not siloed).

Audience Q&A: how to become AI-native (without losing the plot)

The Q&A reinforces a practical learning path:

Build something end-to-end. The fastest way to understand the new tools is to ship a small project.
Develop taste + judgment. Tools will get better; your ability to choose the right problem won't auto-update.
Learn the new collaboration patterns. Teams will need shared norms around prompting, reviewing, and decision-making.

Playbook move: treat learning as a sprint:

pick a small use case,
ship a working version,
then reflect: what sped up, what broke, what decisions were hard?

Chapters & show notes

3:30 Pre-roll: Evermuse overview video
[0:00] Welcome & why this conversation now (Eran)
[0:53] How to use the chat + Q&A, quick intros (Eran)
[3:51] Jake's intro: Design Sprints, Character, and why AI is different
[6:31] The Celebrimbor problem: coding with AI feels like "borrowed superpowers"
[13:20] Why Eran started Evermuse: AI + human alignment, from Buddhist philosophy to product
[16:01] The new bottleneck: backlog scarcity shifts from engineering → customer understanding
[19:16] Product craft moves into code: designers/PMs become "makers" (Cursor, components, systems)
[29:03] Empathy as a durable moat: Apple's principle and the job of understanding customers
[41:48] From AI tools → AI magic: agents, inbox triage, and what "automation" should feel like
[44:10] Audience Q&A: preparing for AI-native roles, how to build teams, and learning by building
[1:06:42] Wrap-up, where to follow, and closing thoughts

Key resources mentioned

Book: Superintelligence (Nick Bostrom) - the "what happens when AI is smarter than us?" framing that shaped Eran's early thinking.
Method: Design Sprint (Jake Knapp) - rapid prototyping + decision-making under uncertainty.
Tools mentioned: Cursor & Claude Code (AI coding environments), Superhuman (email), and Lovable (building apps fast).
People/resource mentioned: Nate B. Jones (YouTube/Substack) for practical AI-building content.

Action items for teams

Run a "customer signal loop" weekly. One conversation + a 30-minute synthesis + one decision input.
Treat prompts like PRDs - just faster. Write requirements in stages and iterate with the model, but keep ownership of the decision.
Move craft into the medium. If you care about the experience, get closer to code (components, performance, transitions, edge cases).
Define what "magic" means for your product. Don't just add AI features - remove work users shouldn't have to do.
Measure learning velocity, not shipping velocity. Speed without direction compounds waste.

About the speakers

Jake Knapp is a New York Times bestselling author (including Sprint and Make Time) and a co-founder/general partner at Character Capital. He previously helped build Gmail, co-founded Google Meet, and was a partner at Google Ventures.

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 all webinar recordings
Book a 1-on-1 demo with the Evermuse team

This post was adapted from the Evermuse live webinar with Jake Knapp. Watch the full recording for deeper nuance and Q&A.