See pricing
How Figma’s PMs actually use AI every day | Ezra Mechaber (PM, Figma)
How I AIAI

How Figma’s PMs actually use AI every day | Ezra Mechaber (PM, Figma)

Figma turned one PM's personal Claude Code setup into a shared repo of 31 skills now used across 60 to 70 PMs. Ezra Mechaber explains which workflows actually matter in practice: Slack triage, org context, AI bug bashing, and an experiment engine that can launch tests with one human checkpoint.

November 2, 2026 · 42 min listen · 13 min read · Ezra Mechaber
0:00
–:––

Context

Ezra Mechaber is a growth PM at Figma who started with a personal AI setup, then helped turn it into PM OS, a shared repo of skills used across Figma's product team. The episode is about a more practical question than "can AI help PMs think strategically": what parts of PM work should be standardized, automated, or delegated first. That matters because many PM bottlenecks in large companies are not vision problems, they are coordination, context, diligence, and follow-through problems. Ezra also shows two higher-end workflows, AI bug bashing and AutoXP, that show what happens once the basics are working.

The Big Idea

The best PM AI workflows start with the work PMs routinely do badly, late, or not at all, then turn that into shared systems that raise the team's baseline and increase how much product work one PM can supervise.

Figma's PM OS worked because it did not begin as a polished "AI product for PMs." It began as a simple repo that automated missing context, messy coordination, and repetitive follow-up, then expanded into more ambitious workflows like bug bashing and experiment generation.

Key Insights

Shared repo beat polished product

  • PM OS is a simple repo, not a full internal product.
  • The repo contains an agents.md file, a set of skills, some command hooks, and a private sub-repo for each PM.
  • That structure let Figma keep 60 to 70 PMs roughly in sync while still allowing each PM to store private context and write back personal work.
  • Ezra's point was practical: internal adoption mattered more than perfect UI. The terminal was good enough to get learning started, then the team moved toward a local web front end, and later into Codex as the tools improved.

Automate neglected PM work

Ezra did not start by asking AI to do the most strategic parts of product management. He started with the jobs PMs often drop or do poorly: looping in support on launches, taking usable meeting notes, finding who owns a system, or writing docs with the right reviewers already named. His test was whether AI could get these tasks to a minimum acceptable level so they stopped creating drag for everyone else.

Context skills compound later work

  • Foundational skills like "who works on this team?" and the Slack digest called "what's up" are not flashy, but they make everything else better.
  • Ezra runs the Slack triage skill about six times a day.
  • The skill pulls together relevant Slack threads, projects, open decisions, and people he owes something to.
  • Once AI knows org structure, stakeholders, and active work, it can draft docs, route reviews, and coach decisions with far less manual setup.

AI bug bashers find weird edges

  • Ezra keeps a standing Codex thread for bug bashing.
  • He gives the model a test account, a path to follow, instructions in FigJam, and a place to write findings back.
  • The main advantage is not originality. It is diligence. The agent follows directions more patiently than a human who gets bored or rushed.
  • Example: the agent found that putting 1,000 emojis in a text box broke the product.
  • Example: the agent also caught copy logic around a team name that started with "A," which changed whether the UI should say "a" or "an." That bug depended on a narrow edge case that had not shown up in earlier human bug bashes.

One checkpoint unlocks experiments

  • AutoXP is Ezra's attempt to "automate myself out of a job" for bounded growth work.
  • The system runs through Cursor automations triggered from Slack.
  • A request can tell AutoXP to find an experiment on a specific page. Then a set of agents handle different parts of the work:
  • a data science agent looks for funnel drop-off and related patterns
  • a UX writing agent proposes copy ideas
  • an engineering agent picks up a PR and implements the test
  • The system writes updates back into the same Slack thread so a human can inspect the chain of work.
  • The key design choice is one human touch before launch. A PM reviews the findings, hypothesis, UX writing, and code together, then the experiment goes live.
  • That structure let one Figma engineer run five live experiments Ezra had not manually reviewed end to end, and AutoXP found a huge win on its first experiment.

Cheap models enable live checks

Ezra's Jev prototype turns AI from an on-demand assistant into a real-time writing partner. When the writer pauses, the tool quickly checks for blanks, unsupported claims, or places where the user's library already contains evidence. The important product lesson is about latency: slower frontier models can feel too delayed for moment-to-moment collaboration, while a fast cheap model can sit in the background and improve the work without breaking flow.

Mental Models & Frameworks

Lazy in right places

Ezra tells his engineers his goal is to be "lazy in the right places." The idea is not to avoid work. It is to remove repetitive work that does not deserve scarce PM attention. Use this model when deciding what to automate first: choose tasks that must happen, but do not benefit much from human originality every single time.

Raise floor, lift ceiling

  • Raise the floor: use AI to make sure basic PM work happens reliably, even when the team is busy.
  • Lift the ceiling: use AI to make work possible that used to be too expensive, like more bug-bash coverage or more concurrent experiments.
  • Ezra explicitly cares about both. A tool that only helps power users is not enough for team-wide adoption.

Shared repo, private workspace

A shared parent repo can hold common skills, hooks, and templates, while a private sub-repo lets each PM keep personal notes, memory, and customizations. This model balances standardization with flexibility. It is especially useful when you want one team-wide way of working without forcing everyone into identical prompts or exposing private working context.

One-checkpoint experiment loop

  • Let agents do discovery inside a bounded surface, such as finding funnel drop-off, drafting copy, and preparing implementation.
  • Insert a human review before launch, when judgment matters most.
  • Let the system analyze results and begin the next round after the experiment runs.
  • Use this model when experiment volume matters, but you still want a clear control point for risk.

Reset poisoned context

When an agent gets stuck in a bad loop, Ezra treats the conversation as unrecoverable instead of arguing with it. His reasoning is that the model may be trapped by earlier bad instructions, stale permissions, or confused state. Use this heuristic when repeated corrections are not improving output. Starting a fresh session is often cheaper than burning more tokens and patience on a broken one.

Decision Principles

Principle: Standardize before you polish

When: rolling AI workflows out to many PMs. Why: PM OS spread because it was easy to share, fork, and improve, not because it had a perfect interface. Figma only worried about nicer fronts after people already had useful workflows.

Principle: Human review at launch

  • When: automating bounded product experiments.
  • Why: Ezra is comfortable letting agents search for opportunities, draft variants, and implement tests, but he still wants one human checkpoint before something goes live. That is the moment where product judgment and risk tolerance matter most.

Principle: Use cheap models continuously

When: the task needs fast background checks, such as spotting blanks or unsupported claims while someone writes. Why: a slower model interrupts flow. Ezra's Jev prototype works because the model feels ambient instead of transactional.

Trade-offs & Nuance

Repo speed versus product polish

PM OS started as a repo because that was the fastest way to build and share it. The downside is usability. Terminal tools are a poor long-term interface for many PMs, especially for writing-heavy work. Ezra's path was to accept rough edges early, then invest in better front ends once the value was proven.

Diligence versus comment noise

AI bug bashers can be more thorough than humans, but they can also be noisy. Ezra said the team is still tuning the system so its comments are useful rather than annoying. Higher coverage is valuable only if the findings are organized well enough that humans will trust and act on them.

Autonomy versus oversight

AutoXP increases experiment cadence by letting agents handle more of the work, but it is still constrained. The sandbox is bounded, and there is a human checkpoint before launch. The trade-off is clear: more autonomy gives more throughput, but weaker control could raise the cost of bad experiments or sloppy implementation.

Privacy versus measurement

Ezra chose not to instrument PM OS usage. He did not want people to feel creeped out, and he wanted the system to stay fun. That protected trust, but it also meant the team relied on Slack feedback and visible adoption instead of hard telemetry about usage patterns.

Common Mistakes

Mistake: Automating only flashy work

Teams often jump straight to strategy documents or impressive demos and ignore the chores that actually create drag, like routing reviews, finding owners, or remembering launch handoffs. Ezra's approach worked because it solved everyday pain first.

Mistake: Trusting manual bug bashes

Human bug bashes are inconsistent. People skip steps, miss edge cases, and lose patience in logic-heavy flows. Ezra's AI bug bashing worked because the agent was willing to exhaust narrow cases that a person would rarely test by hand.

Mistake: Arguing with bad context

When an AI session is stuck, more instructions do not always help. Ezra's view is that some conversations are poisoned by bad state or earlier mistakes. The better move is often to restart cleanly.

Practical Application

List dropped PM chores

Review your last few launches or projects and write down the work that was forgotten, done late, or done poorly. Look for tasks like support handoffs, reviewer routing, stakeholder follow-up, or meeting-note cleanup. Those are strong candidates for first-generation AI skills because they only need reliable baseline quality.

Build a daily Slack digest

Create one routine that pulls together:

  • important threads from the channels you actually depend on
  • decisions still open
  • people waiting on you
  • projects that changed state since the last check

Run it multiple times a day. Ezra's example matters because the win is not better summarization. The win is reducing time lost to scanning and context switching.

Create an owner lookup

Build a lightweight skill that maps products or systems to the relevant PM, designer, engineering manager, and support contact. Call that skill automatically whenever a doc gets drafted. This removes one of the most common coordination failures in larger companies, which is simply not knowing who needs to be in the loop.

Add AI to bug bashes

  • Give an agent a dedicated test account.
  • Provide an explicit path through the product and a list of cases to try.
  • Tell the agent where to write results back, such as a FigJam board or a shared doc.
  • Compare its findings with a human bug bash on the same release.

This works best on flows with lots of state, copy rules, or edge-case combinations.

Pilot one-checkpoint experiments

Pick a low-risk surface with meaningful traffic, then let AI generate bounded experiments on that surface. Keep one human review before launch and one review after results come back. Judge the pilot by whether experiment volume rises without lowering trust in the decisions or the implementation.

Questions to Consider

  • Which recurring PM failures on your team are really neglected chores, such as support handoffs or review routing, that still create real cost when nobody handles them well?
  • If an AI assistant summarized your Slack and project threads six times a day, what decisions, owners, and follow-ups would need to appear for that summary to actually change how you run your week?
  • Where in your product could an AI bug basher test logic-heavy edge cases, such as copy rules, account states, or unusual inputs, more patiently than a human reviewer?
  • If your growth team kept one human checkpoint before launch, what low-risk product surfaces could support more concurrent experiments than you run today?

Bottom Line

Figma's most useful PM AI workflows are not magic prompts. They are shared systems for context, coordination, diligence, and bounded execution. Once those basics are in place, a PM can supervise better bug bashes, more experiments, and faster writing support without pretending human judgment is no longer needed.

Resources Mentioned

ResourceTypeWhy it was mentioned
Jev for beginners: how to use it and what to buildArticleThe feed links this as background for understanding Jev, the fast cheap model Ezra used in his real-time writing assistant.

Tools & Products

Tool / ProductWhat it doesWhy it was mentioned
FigmaDesign and product collaboration platformEzra is a PM at Figma, and the episode uses Figma's internal PM workflows as the main case study.
FigJamCollaborative whiteboard from FigmaEzra uses FigJam boards to structure bug bashes and to let agents write findings back into a shared artifact.
Figma MCP serverConnects models to Figma contextEzra called the Figma MCP setup "insane" and said a PM at Figma built a strong FigJam builder on top of it.
Claude CodeTerminal-based coding agentPM OS started as a repo used inside Claude Code before the team built a local web front end and later shifted more work into Codex.
CodexOpenAI coding agent with browser useEzra now spends most of his time in Codex, especially for browser-driven work like bug bashing.
Cursor AutomationsScheduled or triggered coding workflowsAutoXP runs as Cursor automations that trigger from Slack and coordinate different agent roles.
JevFast cheap classification-style modelEzra used Jev to build a real-time writing assistant that flags blanks and unsupported claims while someone writes.
MarkerWriting appEzra used Marker as one inspiration for the writing experience in his Jev prototype.
InstinctProactive agent over iMessageEzra described using Instinct for lightweight personal tasks, such as reporting potholes, as an example of proactive agent design.

People to Follow

Ezra Mechaber

Ezra Mechaber is a growth PM at Figma and the builder behind many of the workflows discussed in the episode, including PM OS, AI bug bashing, AutoXP, and a Jev-based writing assistant. He is especially relevant for PMs who want concrete examples of internal AI systems, not just prompting tips.

Claire Vo

Claire Vo hosts the show and brings a strong experimentation background to the conversation, including prior work at multiple experimentation-platform companies. That context helps explain why the AutoXP discussion is unusually specific about traffic, cadence, and experiment throughput.

Experiments to Try

Experiment: AI bug bash parity

  • Hypothesis: an AI bug basher will find more edge-case issues than a human-only bug bash on the same release.
  • Change: give a coding agent a test account, a scripted path, several edge-case scenarios, and a place to write findings back.
  • Test: run the AI pass and a human pass separately on one upcoming release.
  • Measure: count unique bugs found, bug severity, false positives, and total reviewer time.

Experiment: One-gate experiment conveyor

  • Hypothesis: one human checkpoint before launch can increase experiment volume on low-priority surfaces without lowering outcome quality.
  • Change: let agents generate hypotheses, draft copy, and prepare implementation for one bounded page or funnel step.
  • Test: run the process for a few weeks on one surface that currently gets little experimentation attention.
  • Measure: compare experiments launched, cycle time, winner rate, engineering time spent, and cleanup cost against the prior baseline.

Notable Quotes

"my goal is to be lazy in the right places." (Ezra Mechaber)

"I, as a growth PM, I feel like the biggest sin you can commit is wasting traffic." (Ezra Mechaber)

"I think we should all be nice to our AI." (Ezra Mechaber)

AI PM course

Everyone hears the same episodes.
Few can do what they describe.

Start for free