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.mdfile, 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
| Resource | Type | Why it was mentioned |
|---|---|---|
| Jev for beginners: how to use it and what to build | Article | The feed links this as background for understanding Jev, the fast cheap model Ezra used in his real-time writing assistant. |
Tools & Products
| Tool / Product | What it does | Why it was mentioned |
|---|---|---|
| Figma | Design and product collaboration platform | Ezra is a PM at Figma, and the episode uses Figma's internal PM workflows as the main case study. |
| FigJam | Collaborative whiteboard from Figma | Ezra uses FigJam boards to structure bug bashes and to let agents write findings back into a shared artifact. |
| Figma MCP server | Connects models to Figma context | Ezra called the Figma MCP setup "insane" and said a PM at Figma built a strong FigJam builder on top of it. |
| Claude Code | Terminal-based coding agent | PM 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. |
| Codex | OpenAI coding agent with browser use | Ezra now spends most of his time in Codex, especially for browser-driven work like bug bashing. |
| Cursor Automations | Scheduled or triggered coding workflows | AutoXP runs as Cursor automations that trigger from Slack and coordinate different agent roles. |
| Jev | Fast cheap classification-style model | Ezra used Jev to build a real-time writing assistant that flags blanks and unsupported claims while someone writes. |
| Marker | Writing app | Ezra used Marker as one inspiration for the writing experience in his Jev prototype. |
| Instinct | Proactive agent over iMessage | Ezra 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)
