Empowering Product Makers in the Age of AI: Webinar Recording + Playbook

How to ship faster with AI—without sacrificing taste, trust, or craft

Make AI do the mechanics--you still decide.

Webinar video

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

Follow our Youtube channel for past webinar recordings →

TL;DR

• We're moving from role-silos (designer / PM / engineer) to makers who can carry work from insight -> prototype -> production--with AI acting like a "team" you manage.
• The risk isn't "UX is dead." The risk is AI demand hijacks organizational attention, and UX rigor gets squeezed first.
• The second era of AI tools is sequences: chained workflows optimized for a profession or use case.
• Trust becomes a product feature. Disclosure, control, provenance, and recourse matter more than ever.
• Your advantage won't be "knowing a tool." It'll be designing the workflow and protecting taste.

Chapters & show notes

• 00:00 — Welcome + how this session works
• 00:20 — Speaker intros + what you'll cover
• 03:10 — Tal's background (engineering -> UX) + why "makers" are the next evolution
• 07:30 — Big shift #1: UX doesn't disappear — attention does (AI squeezes quality/UX bandwidth)
• 13:40 — Becoming managers of AIs: feedback loops + "context management" mindset
• 15:50 — Tooling strategy: pick one "home base" (Lovable vs Cursor vs Replit) + avoid tool-hopping
• 22:20 — "Company-of-one" building: Eran's Replit/Lovable workflow for site/blog/support tools
• 33:40 — Big shift #2: "Sequences" — chaining tools into one-button workflows
• 40:30 — Empathy + trust as product mechanics (what breaks trust first)
• 47:40 — The Maker Ticket idea in practice: define clearly, pass context, review like a team lead
• 53:30 — Quality at speed: Cursor bug-finding + code review bots + AI-generated tests
• 55:40 — Audience Q&A begins + accessibility in AI-coded builds (request + verify)
• 58:40 — Taste: avoiding "everything looks the same" + protecting the ideation phase
• 1:05:10 — Shipping same-day: Linear ticket -> assign to Cursor; A/B testing; ideation vs production separation
• 1:06:50 — Wrap-up, next steps, and resources

Playbook: Empowering Product Makers in the Age of AI

Core thesis: We're moving from role-silos (designer / PM / engineer) to makers who can carry work from insight -> prototype -> production--with AI acting like a "team" you manage.

Who this playbook is for

• Product leaders who need faster shipping without losing craft
• Designers/PMs trying to stay relevant as "UX shrinks" and "maker work expands"
• Founders/operators who want "company-of-one leverage" without chaos

Outcomes (what "good" looks like)

Within 30 days, a team adopting this playbook should be able to:

1. Ship smaller, safer improvements same-day (or same-week) with AI-assisted tickets and reviews
2. Stand up internal tools (support ops, lightweight CRM, content systems) in hours--not quarters
3. Keep (or regain) product trust + taste while accelerating output

The big shifts (what changed)

1) UX doesn't disappear--attention does

Tal's warning isn't "UX is useless." It's: AI demand hijacks organizational attention, and UX rigor gets squeezed first.

Implication: You need lighter-weight UX moves embedded into the maker workflow (not a separate, fragile process).

2) Everyone becomes a manager (of AIs)

As AI takes more execution, humans shift toward:

• defining outcomes clearly
• managing context
• reviewing, correcting, and iterating fast

3) The second era of AI tools is "sequences"

Tal describes moving past "single-feature tools" into combined workflows optimized for a profession or use case (a "single button" that chains capabilities).

Implication: your advantage won't be "knowing a tool." It'll be designing the workflow.

4) Trust becomes a product feature

When users can't tell what's real, trust becomes fragile--and therefore valuable. Tal's example: disclose AI clones up front to avoid trust collapse.

Implication: Build trust mechanics intentionally (disclosure, provenance, human "handoffs," clarity).

The Maker Operating System (MOS)

A lightweight system you can adopt across product/design/engineering.

The 5 loops

1. Listen (continuous): capture customer signals at scale
2. Define: write a "maker ticket" (clear outcome + constraints)
3. Build: AI-assisted implementation (tool depends on complexity)
4. Verify: AI + human review, tests, accessibility/security checks
5. Ship + Learn: release, measure, optionally A/B test

Tooling strategy (don't drown in FOMO)

Principle: pick one "home base" and go deep

Tal's most practical advice: stop tool-hopping. Choose a tool that matches your requirements and become excellent at it.

Suggested "home base" decision tree

If you want visuals-first + minimal code exposure:

• Lovable (Tal's default; "hides code the most," quick start, Supabase under the hood)

If you're building a complex production app (workflows, infra, heavy debugging):

• Cursor (debug/planning, sits on codebase; model choice matters)

If you want "Lovable-ish" plus more developer control:

• Replit (Eran referenced migrating there for site + blog + support tooling)

"Model > tool" rule (for advanced teams)

Cursor-style setups can use stronger models for planning and faster ones for execution (splitting plan vs execution models).

The Maker Ticket template

Use this when assigning work to an AI tool or a human+AI pair.

Title: Verb + outcome (e.g., "Reduce onboarding drop-off on Step 2")

1) Outcome (non-negotiable):

• What should be true when we're done?

2) User + scenario:

• Who is this for and when do they hit it?

3) Constraints:

• Design system rules
• Accessibility minimums
• Security/privacy constraints
• Performance constraints

4) Definition of Done:

• Screens/states covered
• Tests added/updated
• Accessibility check run + issues resolved
• Tracking/analytics events (if relevant)

5) Context pack (the "context management" Tal described):

• links/snippets
• current behavior
• desired behavior
• examples/references

Execution workflows you can standardize

Workflow A: "Company-of-one" internal tools (hours to days)

Best for: landing pages, admin tools, lightweight CRM-ish systems, support tools.

1. Start in Lovable (or Replit) with a rough spec
2. Iterate via "vibe coding" until the core loop works
3. Add a real database + auth only once value is proven (avoid premature hardening)
4. Ship internally, gather feedback, then decide whether to productionize

Why it works: Tal built a homepage + "WordPress-like" management system quickly, then expanded into full systems.

Workflow B: Production app changes with "AI assignment"

Best for: real product iterations where reliability matters.

1. Write Maker Ticket
2. Assign to AI coding tool (ticket -> assign -> AI implements)
3. AI-first verification stack:
   • inline bug finding
   • AI code review bots after commit
   • AI-generated tests
4. Human review for correctness + taste
5. Release behind a flag when appropriate
6. Optionally A/B test if it's a meaningful UX change

Quality without slowing down

Accessibility (minimum viable approach)

Practical guidance: explicitly ask the generator to meet accessibility requirements, then verify with an evaluator checklist and feed failures back into AI.

Standard operating step:

• Run an accessibility audit -> paste issues into AI -> "fix in priority order, don't regress styles."

Troubleshooting (what "good" looks like now)

For complex products, a modern stack looks like:

• AI finds issues while writing code
• AI reviews on commit (multiple bots)
• AI writes tests at scale

Policy suggestion:

• "No PR merges without: (1) bot review clean or addressed, (2) tests updated, (3) a human taste + logic pass."

Trust and empathy as product mechanics

The Trust Ladder

When AI is involved (avatars, automation, even AI-generated comms), treat trust like UX:

1. Disclosure (don't let users "discover" later)
2. Control (can users opt out, escalate to human, correct errors?)
3. Provenance (what is source-of-truth vs generated?)
4. Consistency (don't "shape-shift" personalities or policies)
5. Recourse (easy fixes when AI gets it wrong)

"Empathy at scale" positioning (Evermuse tie-in)

Value: listening to customers at scale, surfacing patterns, and catching frustration you'd miss if you're not in every call.

Playbook move:

• Run a weekly "Voice of Customer Digest" that feeds directly into Maker Tickets.

Taste: the maker differentiator

The warning: AI can homogenize outputs ("everything looks the same") if humans skip the ideation phase.

Guardrails to protect taste

1. Separate ideation from production (these are different mental states)
2. Keep a "taste library" (screenshots of great interactions, motion, typography, onboarding flows)
3. Require one human pass that answers:
   • Does this feel like us?
   • Is it too generic?
   • Is it over-animated / gimmicky?

A simple "Taste Pass" checklist

• Visual hierarchy is intentional (not default)
• Microcopy matches brand voice
• Motion supports comprehension (not "AI flair")
• Empty states + error states exist
• The "one weird thing" (a signature) is present

The "Maker Skills" curriculum (what to train)

Based on the webinar, the skills that matter most:

1. Context management (clear direction, passing info between tools/threads)
2. Manager mindset (feedback loops, "do better than that," iterate)
3. Workflow design ("sequences") (combine tools into a use-case button)
4. Taste (as a lasting moat)
5. Trust mechanics (especially for AI-mediated experiences)

30-day adoption plan

Week 1: pick your home base + ship one internal tool

• Decide Lovable vs Replit vs Cursor (use the decision tree above)
• Build one "painkiller" internal tool (support ops, content admin, lightweight CRM)

Week 2: implement Maker Tickets + assignment workflow

• Standardize the Maker Ticket template
• Route 5 real product improvements through the process

Week 3: verification stack

• Add AI review + test generation to the pipeline
• Add accessibility audit step

Week 4: trust + taste hardening

• Add disclosure/recourse where AI touches the user experience
• Add Taste Pass checklist to PR/release template
• Run first A/B test where appropriate

About the speakers

Tal Florentin is the Founder of SushiLab & ProductMakers. Tal is a UX leader and former software engineer who's spent 20+ years at the intersection of technology and human behavior. Over the past 18 years, he's designed ~300 digital products for Fortune/Top-500 companies, and he's also trained the next generation of Makers as a UX educator and mentor. He founded UXV, Israel's UX certification program, with 900+ graduates who've helped shape the local UX industry, and he's the author of "The UX Design" (published in Hebrew and adapted into English and Chinese).

Eran Dror is the Founder & CEO of Evermuse, and the Managing Partner of Remake Ventures, a venture studio aimed at building human-centered startups. Over the years, he has helped 40+ startups raise $300M+ by finding product-market fit, including his first exit SetJam - a smart TV startup which sold to Motorola in 2012.

Want to learn more?

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