# AI Tools for PMs — full text export --- # Build the context pack so you stop re-explaining your product every session Status: proven. Last verified 2026-07-28. Tested with: Source-checked 2026-07-28 against Claude Code's memory and MCP docs (current as of that date; the 200-line CLAUDE.md guidance and the `@path` import syntax are quoted from them). The step 2 prompt was run against Claude Opus 5. Notion AI's retrieval behaviour was not re-verified in this pass — treat step 1 as tool-agnostic. ## The struggle You ask for a competitive angle and get one that ignores the segment you actually sell to. You ask it to draft a spec and it proposes the integration you killed last quarter, for the second time. So you type the background again — what the product does, who the users are, the constraint that always applies, the thing you already decided — and the next answer is better. Then you open a new tab and it's gone. The instinctive diagnosis is that you need better prompts, and there's a whole genre of advice built on that premise. It's mostly wrong, and you can prove it to yourself: take a generic answer, paste in three paragraphs of real product context, ask the identical question again. The improvement is enormous, and none of it came from phrasing. Prompt craft resets to zero every session. Context, written down once, compounds — across your sessions, and across anyone else's. The reason nobody has one is that building it feels like documentation rather than leverage, so it never wins against whatever is due Friday. ## The chain ### Step 1 — Harvest what's already written · [Notion AI](/tool/notion-ai/) Your context already exists, scattered across shipped PRDs, retro notes, the strategy doc nobody reads and last quarter's board update. Use [Notion AI](/tool/notion-ai/) — or whatever holds your docs — to pull it rather than writing from memory, which is how you end up with an aspirational description of your product instead of a true one. Ask it for: what the product does in plain terms, who the segments are and how they differ, the constraints that always apply, the things you decided *not* to do and why, and the vocabulary your company uses for things. That last one matters more than it sounds: house vocabulary is the fastest tell between an answer written from inside your company and one written from outside it. **Honest trade-off:** if your docs are thin or badly out of date, skip this and write the pack from scratch in step 2. Harvesting bad context is worse than starting clean — you'll launder stale decisions into something that now looks authoritative. ### Step 2 — Compress it into a pack · [Claude](/tool/claude-ai/) The whole point is compression. A pack that's 40 pages doesn't get loaded and doesn't get maintained. Paste the harvest into [Claude](/tool/claude-ai/): ``` Below is raw material about my product, pulled from internal docs. Turn it into a CONTEXT PACK: the standing briefing an assistant should have before answering any question about this product. Target 120 lines or fewer. Structure it as: - What the product is and who it's for (5 lines max) - Segments, and how their needs differ - Constraints that always apply (technical, commercial, regulatory) - Decisions already made and NOT up for debate, each with its one-line reason - House vocabulary: the words we use, and what we mean by them - Open questions we genuinely haven't resolved Hard rules: - Every line must be a specific claim, not a value statement. "Enterprise buyers need SSO before they'll trial" is context; "we're customer-obsessed" is noise. Cut all noise. - If the source material is contradictory or ambiguous, put the item under a "NEEDS A DECISION" heading instead of picking one. Do not resolve it yourself. - Do not add anything that isn't in the source. If a section is thin, leave it thin and say so. Source material: """ """ ``` Then **edit it yourself**, and expect this to be the slow part. Not because the draft is bad, but because the "NEEDS A DECISION" list is where you discover your team never actually agreed on who the primary segment is. Resolving those is the real work, and it's worth more than the pack. ### Step 3 — Make it load automatically · [Claude Code](/tool/claude-code/) A pack you paste is a pack you'll stop pasting. Two ways to make it automatic, and you can do both: - **Claude Projects** — put the pack in project knowledge; every chat in that project starts with it. Zero setup, right answer for most PMs. - **`CLAUDE.md`** — [Claude Code](/tool/claude-code/) reads a markdown file at the start of every session. This one is version-controlled, reviewable in a pull request, and shareable with your team, which makes the pack a team asset rather than your personal trick. Anthropic's [own guidance](https://code.claude.com/docs/en/memory) is to keep `CLAUDE.md` under about 200 lines — longer files consume context and, counterintuitively, *reduce* adherence. If yours is growing, split it with `@path/to/file.md` imports rather than letting one file sprawl. ### Step 4 — Point it at live systems (optional, highest ceiling) A static pack goes stale. [MCP](https://code.claude.com/docs/en/mcp) connects Claude Code to Jira, Figma, Slack, Google Drive or a database, so instead of describing your roadmap you let it read the roadmap. Anthropic's docs give the shape directly: *"Add the feature described in JIRA issue ENG-4521 and create a PR on GitHub."* Skip this until steps 1–3 are habit. It's a setup cost per integration, and a live connection to the wrong system is worse than a good static file. ## Where it breaks - **Writing the product you wish you had.** The single most common failure. A pack full of positioning language makes every answer *more* confidently generic, because you've handed the model marketing copy and asked it to reason from it. Specific claims only. - **Letting it go stale.** A pack asserting a decision you reversed in March is worse than no pack — you'll now get wrong answers with your own authority behind them. Ten minutes a month, or delete it. - **Bloat.** Past a couple of hundred lines, adherence drops and you're paying context for instructions being ignored. If it's growing, split it, don't pad it. - **Laundering assumptions into facts.** Everything in the pack gets treated as true forever. Keep "NEEDS A DECISION" and "Open questions" as real sections, and resist the urge to tidy them away — an honest gap produces better answers than a confident guess. - **Confidentiality.** A context pack is, by design, the most concentrated description of your strategy that exists. Know where it's stored, know your company's policy on what may go into a cloud tool, and keep customer names and unreleased plans out unless you've checked. - **Assuming it fixes reasoning.** Context fixes *relevance*. A model with perfect context can still be wrong about your market. The pack removes an excuse; it doesn't remove your judgment. --- # Write the eval set that defines "done" for your AI feature Status: proven. Last verified 2026-07-28. Tested with: Written and source-checked 2026-07-28 against Anthropic's eval guidance and the promptfoo README (v-current on main). The prompt in step 2 was run against Claude Opus 5. The promptfoo commands are quoted from the project's own README rather than from a local run — verify the config against the current docs before relying on the exact YAML keys. ## The struggle The feature works. You've used it. Your engineer has used it. Someone in the launch review asks the reasonable question — *is it good enough?* — and what you have is a feeling assembled from eleven ad-hoc tries, most of them on inputs you invented, none of them written down. So the decision gets made on confidence rather than evidence, and then the real problem starts: three weeks later someone changes the prompt or the model version moves under you, and nobody can tell whether it got better or worse. There's nothing to compare against. The obvious fix — "let's just test it more carefully" — fails for a specific reason: careful manual testing doesn't survive contact with a second release. It's expensive, it's a different person each time, and its output is an opinion, not a baseline. The thing that fixes it isn't more testing. It's an **eval set**: real inputs, an explicit view of what a good answer looks like, graded automatically, re-runnable in a minute. It's a product document that happens to execute — and writing it needs someone who knows what customers actually need, which is why it lands on you rather than on engineering. ## The chain ### Step 1 — Gather real inputs, not imagined ones (30 minutes) Pull 40 inputs your feature has genuinely seen: support tickets it summarised, queries it answered, documents it classified. Export from the logs, the support tool, wherever they live. Forty is a deliberate number and it's the first place people go wrong. The instinct is to hand-craft eight perfect test cases; [Anthropic's eval guidance](https://platform.claude.com/docs/en/test-and-evaluate/develop-tests) says the opposite in as many words — *"more questions with slightly lower signal automated grading is better than fewer questions with high-quality human hand-graded evals."* Volume is what catches the failure you didn't predict. Eight cases test your imagination. Deliberately include the ugly ones: empty input, input three times longer than normal, input in the wrong language, something abusive, something ambiguous where two answers are defensible. Those are the categories that break in production and never appear in a hand-picked set. ### Step 2 — Draft the cases and the rubric · [Claude](/tool/claude-ai/) Paste the inputs into [Claude](/tool/claude-ai/) and get the first pass of your grading criteria. You are not asking it what good looks like — you're asking it to turn what you already know into something checkable, and to tell you where your own definition is vague: ``` I'm building an eval set for an AI feature. Below are ~40 real inputs it receives. The feature is: . A good output must: <2–4 things you actually care about, in your words>. For each input, produce: 1. A short label for what kind of case it is (typical / edge / adversarial / ambiguous). 2. ONE specific, checkable assertion about what a good response must or must not do for THIS input. Prefer literal checks ("must contain the ticket ID", "must not name a competitor") over subjective ones. Only fall back to a judged criterion ("tone is professional") when nothing literal captures it. 3. If my stated criteria don't determine the right answer for this input, say so and ask me the question instead of guessing. Hard rules: do not invent inputs — use only the ones I gave you. Do not write an assertion you couldn't check mechanically. Flag every case where two different answers would both be acceptable; those are mine to decide, not yours. Inputs: """ """ ``` The last two rules are what make this useful rather than flattering. The cases it flags as ambiguous are the actual product decisions hiding inside your feature — the ones nobody has made yet. Make them. That list is worth the exercise on its own, even if you stop here. ### Step 3 — Make it runnable · [promptfoo](/tool/promptfoo/) In an empty folder, `npx promptfoo@latest init --example getting-started` writes a working config you edit rather than a blank file. Put your prompt in, your 40 cases in, and start with literal `contains` / `not-contains` assertions before touching anything cleverer. Then `npx promptfoo@latest eval` and `npx promptfoo@latest view` for the side-by-side grid. If the YAML is the wall — and for most PMs it is — this is the single best first job for [Claude Code](/tool/claude-code/): point it at the folder and describe the cases in English. It writes the config. You still own what's in it. **When to skip this step:** if your feature ships once and never changes, a spreadsheet of 40 rows you grade by hand is genuinely fine. The tooling earns its cost on the *second* run, not the first. ### Step 4 — Grade the subjective ones with a different model Some criteria won't reduce to string matching — tone, whether a summary preserved the point, whether a refusal was appropriate. For those, use LLM-graded assertions, and grade with a **different model than the one generating**. Anthropic's guidance states it plainly: *"generally best practice to use a different model to evaluate than the model used to generate the evaluated output."* This is the step most teams get wrong, and the failure is silent: a model asked to grade its own output is systematically generous, so your eval passes and your customers still complain. Nothing in the output tells you this is happening. ### Step 5 — Run it on every change, and report the diff The set has done its job the first time someone changes a prompt and you can say *"seven of forty regressed, here they are"* instead of *"it feels worse."* Re-run before each release. Put the pass rate and the flipped cases in the launch doc. Then keep feeding it: every production complaint becomes a new case. An eval set that doesn't grow is a snapshot of what you were worried about in July. ## Where it breaks - **Passing an eval set that misses the real failure mode.** The most dangerous outcome here, because it reads as safety. 100% pass means you covered what you thought to cover. Add every genuine complaint as a case, and be suspicious of a set that has never gone red. - **Grading with the generating model.** Silently inflates every subjective score. See step 4 — this is the single most common technical mistake, and it produces confident, wrong numbers. - **Hand-crafting eight beautiful cases.** The intuitive move and the wrong one. Coverage beats polish; a rough case you actually included beats a perfect one you didn't. - **Letting Claude write the criteria for you.** It should turn *your* judgment into checkable assertions, not supply the judgment. If you can't say what good means for your customers, no tool closes that gap — and that's the part of this job nobody can take from you. - **Cost surprise on LLM-graded assertions.** Every judged case is another model call, on every run. Forty cases with three judged assertions is 120 calls a run; keep literal checks literal. - **Treating the number as the decision.** 92% pass is not a launch approval. It's evidence you bring to a judgment that's still yours — and the seven failures matter more than the ninety-three passes if they're the ones customers hit most. --- # From a three-hour status deck to a one-page memo they actually read Status: proven. Last verified 2026-07-28. Tested with: Source-checked 2026-07-29; the step 2 memo prompt was run against Claude Opus 5 on a week of sample meeting notes, then read for model-specific assumptions and found to have none — it is plain text in, text out. We name ChatGPT in the chain because it's the assistant most PMs already have; if it misbehaves there, tell us and we'll correct this line. ## The struggle Wednesday night, and you're on slide 11. Six of them are screenshots of dashboards your VP has access to. Two exist because a stakeholder asked for them in March. Slide 4 is the detailed engineering status you rebuild every week and have never once been asked about. Thursday morning you present, and within ninety seconds someone jumps to a question that isn't on any slide — because what they actually wanted was the decision you need from them, and it's buried on slide 9 under a heading that says "Next steps." The obvious fix is a template, and it fails for a specific reason: a template standardizes the *slides*, not the *thinking*, so you still spend the three hours hunting status across Slack threads, Jira, and a week of meetings you half-remember, then pouring it into boxes. The real cost isn't design — it's reconstruction. And here's the uncomfortable part this playbook is built around: **for most exec audiences the memo alone is the better artifact, and the deck is cargo cult.** Slides are a presentation format that got mistaken for a reporting format. This playbook removes the reconstruction, forces the update into one page, and treats slides as an optional last step you should usually skip. ## The chain ### Step 1 — Let the week write itself down · [Fireflies](/tool/fireflies-ai/) Connect Fireflies to your calendar once ([setup docs](https://guide.fireflies.ai/)) and stop taking status notes. By Thursday you have summaries and action items for every meeting you attended — the raw material for the update, captured while you were busy being in the meeting. Pull the week's summaries into one document; that's your input, and it takes about five minutes. The point of a bot notetaker here isn't better notes than yours. It's *complete* notes across 6–10 meetings, which is the thing you cannot do while participating. Configure it to record only the meetings that matter — Fireflies' meeting controls let you exclude 1:1s and personal calls, and you should, both for signal and for the consent reasons below. **When to swap it out:** if you need capture without a visible bot in the room, [Granola](/tool/granola/) records from system audio instead. If your bottleneck is CRM logging rather than PM updates, [Fathom](/tool/fathom/) leans that way. Any of the three feeds step 2 identically. ### Step 2 — Compress to one page, in a format that never changes · [ChatGPT](/tool/chatgpt/) > **Any frontier model runs this step.** Claude and Gemini do this job as well as ChatGPT does; the prompt is plain text in, text out. We name ChatGPT because it's the one most PMs already have (see *last field-tested* above) — not because it's required. Use whichever you already pay for. One prompt, one page, four sections, same order every week. The consistency is doing real work: an exec who has read your memo three times knows exactly where the ask is, which means they read the ask. ``` You are writing my weekly update to an executive audience. The source material below is my meeting notes and summaries from this week. That is the only material you have. Write ONE page, maximum 400 words, in exactly these four sections: SHIPPED — what actually landed this week. Past tense, verifiable, one line each. SLIPPED — what didn't land, and why, in one clause. Name the cause. No hedging verbs: not "we're working to align on scope" but "scope grew after legal review". DECISIONS NEEDED FROM YOU — maximum 3. Each one: the decision, the realistic options, my recommendation, and the date after which waiting gets expensive. RISKS — maximum 3. Each one: the risk in a sentence, and the single piece of evidence that would change my mind about it. Hard rules: - Use ONLY what is in the notes. Do not infer status, invent percentages or dates, or convert "we discussed X" into "X is decided" or "X is done". - Anything you cannot attribute to a specific note goes at the bottom under "Unconfirmed — needs check", with one line on why it's uncertain. Leave it there. Do not promote it into the four sections above. - When someone committed to something, quote them verbatim and name them. - No progress adjectives — no "great", "strong", "on track", "solid" — unless those words appear in the notes. - If a section has nothing in it, write "Nothing this week." Do not fill it. Notes: """ """ ``` The "Unconfirmed — needs check" quarantine is the load-bearing rule. Status updates fail in one direction: a hallway remark becomes "aligned", an intention becomes a commitment, and three weeks later an exec is annoyed because they were told something was decided. Quarantining the unattributable turns that failure into a visible list of five things you have to go ask about — which is a useful to-do list, not a risk. For the standalone version of this prompt, see [stakeholder update memo](/prompts/stakeholder-update-memo/); for the discipline of writing the argument before any slides exist, [write the exec summary before the slides](/prompts/write-the-exec-summary-before-the-slides/). ### Step 3 — Slides only if the audience genuinely needs them · [Gamma](/tool/gamma/) Read this before you open a deck tool. Slides are worth building when there's a live room to walk through the material, when the audience includes people who won't read a doc, or when you're arguing for something and need a visual — a roadmap shift, an architecture, a chart that carries the argument. Board and steering-committee formats sometimes simply require a deck, and that's a legitimate reason. Otherwise: send the memo. If you do need slides, paste the finished memo into [Gamma](https://help.gamma.app/) and let it generate the deck from your one page. That ordering matters — the memo is the source of truth and the deck is a rendering of it, so the argument can't quietly drift while you're picking layouts. Ten minutes, no restyling. **When to skip entirely:** if your last three decks produced no questions and no decisions, they weren't read. Stop making them and see whether anyone asks. Nobody ever has. ### Step 4 — The human check: verify every decision you're asking for Before you send, go through the DECISIONS NEEDED section line by line yourself. For each one: is this actually a decision *they* own, or one you're deferring? Are the options real, or is one of them a straw man? Is the recommendation the one you'd defend out loud? Is the deadline true? This is the part that cannot be delegated to a model, because it's the only part that costs your audience anything. Everything else in the memo is information; these three lines are a request. Wes Kao's [framing](https://newsletter.weskao.com/p/how-to-present-to-your-ceo) is the right test — be specific about what's blocking you and what you need, and weight the update toward what happens next rather than what already happened. A wrong or lazy decision ask is worse than no memo: it burns the attention you'll need for the real one. Clear the "Unconfirmed" list in the same pass — resolve what you can, delete the rest, and never ship the section itself. ## Where it breaks - **The fixed format needs one-time buy-in.** Sending a differently-shaped update unannounced reads as unilateral, and someone will ask where their table went. Spend fifteen minutes once: show your VP the four sections, ask what's missing, adjust, then never change it again. That conversation is the actual unlock — the prompt is downstream of it. - **You cannot summarize your way out of an unclear strategy.** If your memo is honest and still reads as thin, the problem isn't the format. A one-page update makes a directionless quarter *more* visible, not less, because there's nowhere for filler to hide. That's a feature, and it means the fix is a strategy conversation, not a better prompt. - **Meeting-recording consent.** A bot joining every call records your colleagues, and sometimes customers, in jurisdictions with real two-party consent laws. Announce it, let people opt out without friction, exclude 1:1s and anything sensitive, and check your company's policy before pointing a notetaker at external calls. Read the Security section of the [Fireflies docs](https://guide.fireflies.ai/) rather than assuming defaults are compliant. - **"Nobody reads slide 4" sometimes means "send five lines in Slack".** For a healthy project with no decisions pending, the correct weekly update is: shipped X, next is Y, no asks. Three lines, in a channel, done. Running this whole chain to produce a one-page memo that says nothing is a smaller version of the same waste. Match the artifact to the week you actually had. - **The model launders uncertainty into confidence.** Even with the guardrails, a summarizer will smooth "Priya seemed uneasy about the timeline" into "timeline confirmed with Priya." Read the SHIPPED and SLIPPED lines against your own memory of the week, not just against the notes. If a line surprises you, it's wrong — and you're the only reader who can tell. --- # From unwatched interview recordings to an evidence-backed PRD Status: proven. Last verified 2026-07-23. Tested with: Field-tested 2026-07-23; exact model and tool versions weren't recorded at the time — that's why tested_with now exists. Recorded properly from this pass onward. ## The struggle You did the hard part. You recruited, you scheduled, you ran eight real conversations with real users. Then the quarter caught fire, and the recordings went where recordings go to die. Now the PRD is due, its "Problem" section is running on vibes and memory, and the sharpest person in the review knows it — "how many customers actually said this?" — and you nod along, because the honest answer is *somewhere in seven hours of video I'll never re-watch*. The failure isn't laziness. Re-watching is a seven-hour tax nobody pays twice, so the knowledge quietly evaporates and every PRD after that gets written from the same three anecdotes. This playbook removes the tax: capture becomes passive, synthesis becomes a 20-minute prompt with a built-in lie detector, and the output drops straight into the PRD section that was running on vibes. ## The chain ### Step 1 — Capture without babysitting · [Granola](/tool/granola/) Connect Granola to your calendar once ([setup guide](https://docs.granola.ai/help-center)). It captures your calls from system audio — no bot joining the meeting to make interviewees self-conscious — and merges your typed half-notes with the transcript. From here on, every interview lands as clean text automatically. That's the whole point: the pipeline starts *passive*, so it survives busy quarters. **Honest trade-off:** if you need a generous free tier or bulletproof speaker labels on messy multi-voice calls, [Otter.ai](/tool/otter-ai/) is the better capture layer — at the cost of a visible bot in the room. And if your interviews are *already recorded* (the exact rot this playbook targets), skip capture entirely: export whatever transcripts your Zoom/Meet plan gives you and go straight to step 2. ### Step 2 — Synthesize with a lie detector · [Claude](/tool/claude-ai/) > **Any frontier model runs this step.** ChatGPT and Gemini do this job as well as Claude does; the prompt is plain text in, text out. We name Claude because that's what we field-tested with (see *last field-tested* above) — not because it's required. Use whichever you already pay for. Label each transcript `P1`–`P8` (attribution survives synthesis this way) and paste them into one Claude conversation — its long context holds all eight comfortably; past ~10, batch in fives and merge. Then run: ``` You are a user researcher synthesizing interviews. Below are 8 transcripts, labeled P1–P8. 1. Identify recurring themes ACROSS participants (not per-interview summaries). 2. Rank themes by how many distinct participants raised them — show the count. 3. For each theme: one-line description, the participants who raised it, and 2–3 VERBATIM quotes, each tagged with its participant. 4. Separately list surprises — single-participant signals that feel important. Hard rule: every quote must be word-for-word from the transcripts. If you can't find a real quote for a theme, say so instead of paraphrasing. Do not soften or merge quotes. Transcripts: """ """ ``` The verbatim-quote rule is the load-bearing part. It converts "trust the AI" into "check the AI": every claim arrives with a checkable citation. ### Step 3 — Spot-check before you ship it (30 minutes, not optional) Pick the top three themes and grep each quote against the source transcript. Word-for-word matches → trust the pattern and move on. Paraphrased or "improved" quotes → re-run with the hard rule stated more forcefully, and distrust that theme until verified. This half hour is what makes step 4 defensible in front of the room — skip it and you've replaced "vibes" with "confident vibes." ### Step 4 — Drop the evidence into the PRD Paste your verified themes into the PRD's Problem section with counts and quotes attached: *"6 of 8 participants described losing trial users during workspace setup — 'I honestly couldn't tell if it was broken or loading' (P3)."* Next review, "how many customers actually said this?" has a number for an answer, with a named human behind it. ### Optional — Make it durable · [Dovetail](/tool/dovetail/) Solo PM, occasional interviews? Stop at step 4 — a research platform is overhead you don't need. But if interviews arrive weekly, import transcripts and verified highlights into [Dovetail](https://docs.dovetail.com/) while they're fresh. One caveat as of 2026-08-03: Dovetail's free plan is capped at one channel and one project, and the self-serve paid tier is gone, so "several PMs share discovery" now means an Enterprise sales call rather than a $15 seat. Six months later, "pricing objections" is a searchable query returning tagged, attributed quotes across every study — instead of a seven-hour tax nobody pays. ## Where it breaks - **Skipping step 3.** The single biggest failure mode. LLMs paraphrase convincingly; an unverified quote in an exec review costs you more credibility than having no quote at all. - **Unlabeled transcripts.** Without `P1`–`P8` labels, attribution dies in synthesis and every quote becomes "someone said." Label before pasting, not after. - **Too much context.** Past ~10 transcripts in one shot, theme quality degrades quietly. Batch in fives, then run a merge pass on the two theme lists. - **Outsourcing your judgment.** Torres and Wille's [warning](https://www.producttalk.org/customer-interview-analysis-all-things-product-podcast-with-teresa-torres-petra-wille/) applies: AI compresses *what was said*, not *what it felt like to hear it*. Use the machine for recall and coverage; keep interpretation — what actually matters for the product — yours. - **Consent and privacy.** Recording tools and LLMs are processors of your users' words. Record with consent, strip PII you didn't need, and check your company's data policy before pasting transcripts into any cloud tool. --- # Ship the small internal tool yourself instead of filing a ticket nobody picks up Status: proven. Last verified 2026-07-28. Tested with: Source-checked 2026-07-28 against the Claude Code overview and cost docs (install command and per-developer cost figures quoted from them). Replit Agent's current UI was not re-verified in this pass — step 4 is written at a level that survives UI drift, but confirm the deploy flow before relying on it. ## The struggle Support asks for it every month. It would take an engineer two days. It has never once beaten anything else on the roadmap, and it never will, because the honest comparison is *two days of engineering* against *revenue*, and internal convenience loses that comparison forever. So you decline it again, and the team keeps doing the thing by hand. The obvious fix — "just prioritise it" — doesn't fail because your team is unreasonable. It fails because it's correctly prioritised. It genuinely is worth less than the roadmap items above it. It's simply also worth more than zero, which is what it gets. The other obvious fix — build a prototype — misses too. A prototype doesn't solve this; it produces a demo of the solution and then still needs an engineer to build the real one. What changed recently is that for a narrow class of software — internal, few users, no revenue at risk, no customer data — the thing you build *is* the real one. That class is bigger than most PMs realise, and shipping into it is the highest-leverage thing on this site. ## The chain ### Step 1 — Pick something that genuinely cannot hurt anyone This step decides whether the rest is sensible or reckless, so be strict. Good first candidates: a dashboard over a CSV export, a form that writes to a spreadsheet, a lookup tool over data your team already has, a script that reformats a weekly report. Disqualifiers, any one of which ends it: it touches customer data, it writes to a production system, it needs real authentication, it would embarrass you if it were wrong for a week, or it's the kind of thing someone would quietly come to depend on for a decision that matters. "Internal" is not a synonym for "safe" — it just narrows the blast radius. Write down who the five users are. If you can't name them, it isn't the right first project. ### Step 2 — Set the context before you build · [Claude Code](/tool/claude-code/) Install [Claude Code](/tool/claude-code/) (`curl -fsSL https://claude.ai/install.sh | bash` on macOS, Linux or WSL — but check [the docs](https://code.claude.com/docs/en/overview) for the current line). Make an empty folder, and before asking for anything, write a short `CLAUDE.md`: what the tool is for, who uses it, what it must never do, and the constraint that matters most ("one HTML file, no build step, no server"). Skipping this is the most common way these projects go wrong. Without it, session two happily rearchitects what session one built, and you have no idea why. ### Step 3 — Build the thinnest version that's genuinely useful Describe the tool and ask for the smallest thing that works. Then look at it, and correct it. That loop is the entire skill: ``` Build the smallest working version of this tool: WHAT IT DOES: WHO USES IT: INPUT: OUTPUT: Constraints: - Smallest thing that works. No auth, no database, no framework unless I ask. - One file if possible. - Where you had to guess something I didn't specify, list those guesses at the end under ASSUMPTIONS. Don't bury them in comments. - If what I've asked for is a bad idea, or genuinely needs a real engineer, say so before you build it rather than building it anyway. Then tell me exactly how to run it. ``` The ASSUMPTIONS list is the load-bearing part. It's where you find out it decided your dates were US-format, or that it invented a status field you don't have. Read that list before you read the code. **Honest trade-off:** if you want the thing hosted at a URL with no local setup — because your five users won't install anything — [Replit Agent](/tool/replit-agent/) is the better starting surface. You trade editing precision for the deploy problem disappearing, which for a first project is often the right trade. ### Step 4 — Put it in front of one real user, then stop Show it to one of your five. Watch them use it without helping. Fix the two things that made them hesitate. Then **stop building** and let it sit for a week. The failure mode here isn't a bad tool, it's scope: it works, so you add a feature, then another, and you've quietly created an unmaintained internal system with one owner who has a different day job. A tool that does one thing and is finished is the win. ### Step 5 — Tell your engineers what you did Not for permission — for two reasons that are both in your interest. First, someone should know it exists, so it doesn't become an unowned dependency discovered during an incident. Second, it changes what you're allowed to ask for next: a PM who has shipped something, however small, argues about effort estimates from a different position. ## Where it breaks - **Scope creep into something load-bearing.** The real risk, and it's gradual. A tool five people use for convenience becomes a tool forty people use for decisions. The moment that happens it needs an owner who isn't you — hand it over or turn it off. - **Confident, fast wrongness.** An agent doesn't refuse when it's out of its depth; it produces something plausible at speed. On a codebase you don't understand you have no way to notice. This is exactly why step 1's restrictions aren't optional. - **Security assumed rather than checked.** No auth is fine for a local script and not fine for something on a URL. If it ends up hosted, someone who knows what they're doing needs to look at it before it holds anything sensitive. - **Silent data errors.** The tool renders a number; nobody checks the number. Verify the first week's output against the manual process it replaced before anyone trusts it. - **Cost drift.** Claude Code bills on token consumption, and long unfocused sessions are the expensive kind — Anthropic's [cost docs](https://code.claude.com/docs/en/costs) put enterprise usage at ~$13 per developer per active day. Clear between tasks. - **Thinking this makes you an engineer.** It doesn't, and pretending otherwise is how the first three failure modes happen. It makes you someone who can ship a narrow class of small things — which is genuinely valuable, and a much better claim to defend. --- # From competitor surprises to a 30-minute weekly sweep sales actually reads Status: proven. Last verified 2026-07-28. Tested with: Source-checked 2026-07-29; the step 1 sweep prompt and the step 2 delta prompt were run against Claude Opus 5, with the sweep also spot-run in Perplexity. The step 2 prompt carries no model-specific assumptions, so the chain names ChatGPT — the assistant most PMs already have. Notion's battlecard step is a storage surface and was not re-verified in this pass. ## The struggle The deal review is where it lands. Someone says the prospect went with Acme because of a feature you didn't know existed, and everyone turns to you. You open Acme's site for the first time in six weeks and there it is — shipped, on the pricing page, with a launch post from eleven days ago. Now you spend the rest of the afternoon reconstructing what changed, fielding "so what do I say to my pipeline?" in Slack, and quietly wondering what else you've missed. That afternoon costs about four hours, and you'll pay it again next quarter, because nothing you learned got written down anywhere durable. The obvious fix — "I'll check their changelogs every Monday" — dies in week three. Not because you're lazy, but because a manual sweep across five competitors is 45 minutes of tab-opening for an output that usually reads "nothing much changed," and nobody sustains a 45-minute ritual with a mostly-empty result. So the habit lapses, and the intelligence arrives the expensive way: from a lost deal. This playbook makes the sweep cheap enough to survive a bad week — a saved prompt, a diff instead of a rewrite, and a battlecard that lives where sales already looks. ## The chain ### Step 1 — Save one sweep prompt you never rewrite · [Perplexity](/tool/perplexity/) Create a Space (or just a pinned thread) for competitive sweeps and paste this prompt in once. Every Monday you change the date and the competitor names stay put. Perplexity is the right first link because it searches live and returns sources inline; the [prompt guide](https://docs.perplexity.ai/docs/agent-api/prompt-guide) is blunt that specificity in the query is what improves retrieval, which is why this prompt names categories instead of asking "what's new with Acme". ``` Weekly competitive sweep. Today is . Window: the last 7 days ONLY. Competitors: , , . For EACH competitor, report these four categories in this order: 1. Changelog / release-notes entries 2. Pricing or packaging page changes (tiers, prices, limits, add-ons, trials) 3. Product launches or public announcements 4. Funding, acquisition, or leadership changes Rules: - Every claim needs a source URL on the same line as the claim. No link, no claim. - If a category has nothing, write exactly: "No change found — checked ." Do NOT pad the section with older news, company background, or general commentary to make it look complete. - Do not describe marketing copy as a shipped feature. If something is a waitlist, private beta, or "coming soon", label it that way in the line. - Anything you cannot date inside the last 7 days goes at the very end, under "Older or undated" — not in the per-competitor sections. - No summary, no analysis, no recommendations. Findings only. ``` The two load-bearing rules are the source link and the mandatory "no change found" line. Without the first, you get plausible launches that never happened. Without the second, a model with nothing to report will invent something to report — a quiet week reads as suspicious to a text generator, so you have to make "quiet" an acceptable answer. **When to skip Perplexity:** if you only track one competitor, RSS on their changelog plus a Google Alert is free and better. And for traffic or market-share trends rather than announcements, [Similarweb](/tool/similarweb/) answers a different question than any search tool will. ### Step 2 — Diff, don't rewrite · [ChatGPT](/tool/chatgpt/) > **Any frontier model runs this step.** Claude and Gemini do this job as well as ChatGPT does; the prompt is plain text in, text out. We name ChatGPT because it's the one most PMs already have (see *last field-tested* above) — not because it's required. Use whichever you already pay for. Paste last week's battlecard and this week's raw sweep into one ChatGPT conversation. You are not asking for a summary — you're asking what changed, which is the only part you have to read. ``` You maintain a competitive battlecard. Two documents follow: A) LAST WEEK'S BATTLECARD B) THIS WEEK'S RAW SWEEP (claims, each with a source URL) Output ONLY the delta, in these five sections: 1. NEW — present in B, absent from A. One line each, with the source URL. 2. CHANGED — contradicts or updates a line in A. Quote A's old line verbatim, then the new line, then the source URL. 3. STALE — lines in A that B suggests are now out of date. Say which line and why. 4. NO CHANGE — name every competitor with nothing new this week, one line each. I want to see this stated, not infer it from silence. 5. SALES LINE — one sentence, max 25 words, the single most deal-relevant item this week, in language a salesperson can say out loud. If nothing this week is deal-relevant, write "Nothing sales-relevant this week." Hard rules: - Tag every claim [STATED] if the source says it plainly, or [INFERRED] if you concluded it. Every [INFERRED] claim must carry your reasoning in brackets. - Use only what is in B. No outside knowledge, no filling gaps, no guessing at a competitor's motive or roadmap. - Do not restate A. If a section is empty, write "None." - Do not rewrite the battlecard. Delta only. A) LAST WEEK'S BATTLECARD: """ """ B) THIS WEEK'S RAW SWEEP: """ """ ``` The `[STATED]` / `[INFERRED]` tag is what makes this reviewable in ten minutes. "Acme raised prices 20%" and "Acme is moving upmarket" are different kinds of sentence, and only one of them survives a sales rep repeating it to a prospect. Building the battlecard for the first time is a separate job — [build a competitor battlecard](/prompts/build-a-competitor-battlecard/) is the one-off prompt for that, and [positioning one-pager from competitor sites](/prompts/positioning-one-pager-from-competitor-sites/) covers the quarterly version where you rethink the framing rather than track the changes. ### Step 3 — Put the battlecard where sales already looks · [Notion AI](/tool/notion-ai/) One page per competitor, one shared parent page, in the workspace your go-to-market team already has open. Apply the delta by hand or have [Notion AI](https://www.notion.com/help/category/notion-ai) fold it into the existing structure so the card keeps one voice instead of accreting five weeks of paste jobs. Keep a dated "changed this week" line at the top of each card — that line is what a rep reads before a call, and it's the only part they'll read. **Honest trade-off:** Notion AI is the smallest link in this chain. What matters is location, not the AI — a battlecard in Confluence, Google Docs, or your CRM works identically if that's where sales lives. A beautifully maintained card in a tool only PMs open is worse than a scruffy one in the sales channel. ### Step 4 — The human check: verify, then tell one person Two things only you can do. First, open the source link for every claim you're about to put in front of sales. Anything tagged `[INFERRED]`, anything about pricing, and anything that sounds like a big launch gets clicked — that's about five minutes and it's the difference between intelligence and rumor. Second, post the sales line in the channel where reps actually talk, tagged to the competitor, with the link. One line, every week, including the weeks when it says "nothing sales-relevant." That last habit is the whole point. A battlecard that updates silently is a file. A weekly line in a channel is a signal reps come to expect — and intel nobody reads is worth exactly zero, no matter how accurate it is. ## Where it breaks - **Hallucinated launches.** The most common and most expensive failure. Ask a search tool what's new and it will find you something new, including a feature announcement assembled from a blog post's aspirational paragraph. This is why the source-link rule is non-negotiable and why step 4 exists: a rep who repeats an invented competitor feature to a prospect loses credibility you can't refund. If a claim has no link, delete it — don't go looking for the link yourself. - **Public sweeps only see the public.** Enterprise announcements delivered under NDA, private roadmap briefings, quiet pricing given to a single large account, sales-deck claims never published anywhere — none of it shows up in a changelog sweep. Ever. Your highest-signal competitive intelligence still comes from win/loss conversations and your own reps, and this workflow doesn't replace either. Treat "no change found" as "nothing public changed." - **A battlecard nobody opens is theatre.** It is genuinely possible to run this workflow flawlessly for six months and have zero effect on a single deal. The tell is silence: no rep ever replies to your weekly line, no one asks a follow-up. If that's your situation, stop maintaining the card and go ask two reps what they actually needed in their last competitive deal. Then maintain only that. - **Competitor obsession, dressed up as rigor.** A weekly sweep is a very comfortable way to feel productive while learning nothing about your customers. [April Dunford's point](https://www.aprildunford.com/post/positioning-and-competition) is the guardrail: most of the alternatives you track aren't on your prospects' shortlists, and the status quo beats you more often than any named rival. Thirty minutes a week is the budget. If it's creeping toward two hours, you've swapped a customer problem for a competitor hobby. - **Week one has no baseline.** The first run has nothing to diff against, so it returns everything and looks like an emergency. Build the battlecard first, sit on it a week, then start sweeping — otherwise you'll conclude the workflow is noisy when it's just uncalibrated. --- # The PRD that survives the review Status: proven. Last verified 2026-07-28. Tested with: Source-checked 2026-07-28; the step 1 and step 3 prompts were run against Claude Opus 5 on a sample PRD. The ChatPRD and PRDKit UIs were not re-verified in this pass — both appear in the chain as document surfaces, and the steps are written to survive their UI changing. ## The struggle You spent four hours on the PRD. In the review someone asks what happens to existing customers on the old plan, someone else asks why not the cheaper option, and your VP asks what you'd cut if you had half the time. All three are fair. All three were findable the night before. You go away and rewrite it, and the two weeks you lost weren't spent on the hard part — they were spent discovering that you'd never written down the argument, only the plan. The obvious fix is "get feedback earlier," and it mostly fails in practice: the people whose objections matter are the ones with no time to pre-read, which is exactly why they raise the objection live. What actually works is running the review against yourself first, in the specific voices of the people who'll be in the room. The second thing that fixes it is sequencing. Everyone writes the PRD and then summarises it. Do it the other way. A one-page summary is the only artefact short enough that a missing argument has nowhere to hide — if you can't write it, you don't have a position yet, and no amount of PRD structure will conceal that from a good reviewer. ## The chain ### Step 1 — Write the exec summary first · [Claude](/tool/claude-ai/) Before the PRD. Give [Claude](/tool/claude-ai/) your rough idea and make it interrogate the argument rather than dress it up: ``` I'm about to write a PRD. First, help me write the one-page exec summary that would go in front of leadership — because if I can't write it, I don't have a position yet. My rough idea: <2–3 paragraphs, however messy> Produce: 1. The problem, in one sentence, from the CUSTOMER's point of view. 2. Why now — what changed that makes this the right quarter. 3. The proposal in three sentences. 4. What we are explicitly NOT doing. 5. The single number that would tell us this worked. Hard rules: - Where I haven't given you enough to write a section honestly, write "INSUFFICIENT — I need to know: " instead of filling it. Do not smooth over a gap. - Do not invent metrics, market sizes, or customer counts. If a number would strengthen this, name the number I should go and find. - If my "why now" is weak, say so directly. ``` The `INSUFFICIENT` lines are the deliverable. That's the review happening early, on your own time, where it's cheap. Go and answer them before writing a word of the PRD. Our standalone version of this is [write the exec summary before the slides](/prompts/write-the-exec-summary-before-the-slides/). ### Step 2 — Draft the structure · [ChatPRD](/tool/chatprd/) Now the PRD itself. [ChatPRD](/tool/chatprd/) is template-driven and cheap, and it's good at the parts that are genuinely boring — sections, edge cases, the shape of a spec. Feed it the exec summary you just fought for, not the original rough idea, and the draft comes out arguing for something instead of describing something. **When to skip this step:** if your company has a PRD template you must use, drafting in [Claude](/tool/claude-ai/) with the template in project knowledge is a shorter path than fitting a tool's structure to your own. The prompt-library version is [PRD first draft from a rough idea](/prompts/prd-first-draft-from-a-rough-idea/). ### Step 3 — Red-team it with the actual room · [Claude](/tool/claude-ai/) The step people skip, and the one that changes the outcome. Not "review my PRD" — that produces polite generalities. Name the skeptics: ``` Below is my PRD. Attack it. The reviewers will be: - , who always asks about - , who owns and will resist because - , who will ask what we'd cut to ship this in half the time For EACH reviewer, give me: 1. The three hardest questions they will actually ask, in their voice. 2. For each: whether my PRD currently answers it. Quote the line that does, or say "NOT ANSWERED". 3. The one question in this set I am least prepared for. Then, separately: what is the strongest argument for NOT doing this at all? Make that argument properly — steelman it, don't strawman it so I feel better. Hard rules: do not suggest improvements to wording. I want objections, not edits. Quote my PRD verbatim when you say something is answered. PRD: """ """ ``` "Quote the line that does" is the guardrail that makes this trustworthy — it converts *"looks well covered"* into a citation you can check. And the steelman at the end is the highest-value paragraph: if you can't answer it, you have a genuine product question, not a document problem. Our standalone version: [red-team your PRD](/prompts/red-team-your-prd/). ### Step 4 — Repair, don't rewrite (25 minutes) For each `NOT ANSWERED`, do one of exactly two things: answer it in the PRD, or add it to an explicit **Open questions** section with who will answer it and by when. Resist the urge to make the document longer to look thorough. An open question you named yourself is a strength in a review; the same question found by your VP is a weakness. That asymmetry is the whole game. ### Step 5 — Acceptance criteria that engineering can build from · [PRDKit](/tool/prdkit/) The last mile is turning agreed scope into criteria specific enough to argue about before the sprint rather than during it. [PRDKit](/tool/prdkit/) goes from spec to user flows and wireframes, which is useful when the ambiguity is about the *shape* of the thing rather than its logic. If it's the logic, our [acceptance criteria from a user story](/prompts/acceptance-criteria-from-a-user-story/) prompt is faster and tool-agnostic. ## Where it breaks - **Red-teaming with generic reviewers.** "Act as a critical stakeholder" produces polite, useless output. The specificity — real names, real known objections — is what makes this work. If you can't name three skeptics, ask why you're holding a review. - **Accepting the summary instead of arguing with it.** The exec summary is supposed to be uncomfortable. If the first draft feels fine, you probably gave it enough material to paper over the gap you actually have. - **Adding length to look thorough.** A red-team that produces twelve new paragraphs has usually made the PRD worse. Most `NOT ANSWERED` items belong in Open questions, not in new prose. - **Believing the quotes without checking.** Ask for verbatim quotes and then actually check two of them against your document. Models paraphrase persuasively, and a claim that your PRD "already addresses" something it doesn't is the one failure mode here that costs you in the room. - **Outsourcing the position.** These tools sharpen an argument you have. They cannot supply one. A PRD that's structurally perfect and says nothing gets rejected more slowly, not less. --- # From a roadmap that gets re-litigated to a review that ends in a decision Status: proven. Last verified 2026-07-28. Tested with: Source-checked 2026-07-29; the step 2 narrative and pre-mortem prompts were run against Claude Opus 5 on a sample scored roadmap. The Productboard and Gamma UIs were not re-verified in this pass — they appear in the chain as the evidence store and the deck surface, and the steps are written to survive their UI changing. ## The struggle Third month running. You open the same roadmap, and forty seconds in, the same VP asks the same question — "why is billing ahead of the mobile work again?" — and the room resets to zero. You have an answer. You had it last month too. But it lives in your head, or in a Slack thread from March, or in a customer call nobody else heard, so it doesn't survive contact with a confident senior person who remembers the conversation differently. By minute twenty you're not defending a roadmap, you're re-negotiating it, and you'll walk out with an action item to "come back with more data." The obvious fix is a better deck, so you spend six hours on one, and it doesn't work — because the deck was never the problem. The problem is that the *reasoning* behind each priority isn't inspectable: nobody can trace "billing is first" back to the customer signal that put it there, so it degrades into your opinion versus theirs, and opinions get re-litigated for free. This playbook makes the reasoning traceable, rehearses the objections before the room raises them, and cuts prep to about two hours — so the review spends its time on decisions instead of on archaeology. ## The chain ### Step 1 — Make the priority order traceable · [Productboard](/tool/productboard/) Before any slide exists, make Productboard the thing you present *from*, not a tool you export out of. For each of the top items on the roadmap, confirm three attachments: the customer insights linked to it (Productboard's whole point is that feedback notes attach to features), the score that put it in that position, and the objective it ladders to. Then build the one view you'll actually show — features ordered by score, with insight counts visible. See the Prioritization and Roadmapping and Customer Insights sections of the [support hub](https://support.productboard.com/hc/en-us) for how linking and roadmap sharing work. The point of this step is a specific sentence you'll be able to say out loud: *"Billing is first because 23 accounts raised it, 9 of them in the enterprise segment, and here they are."* That sentence is not re-litigable. "I think billing matters more" is. **When to skip:** if your priorities aren't scored yet, stop — you don't have a defense problem, you have a prioritization problem, and no amount of downstream tooling fixes it. Score first ([RICE with AI](/prompts/score-a-backlog-with-rice-using-ai/) is a fast first pass), then come back. ### Step 2 — Draft the narrative, then attack it · [Claude](/tool/claude-ai/) > **Any frontier model runs this step.** ChatGPT and Gemini do this job as well as Claude does; the prompt is plain text in, text out. We name Claude because that's what we field-tested with (see *last field-tested* above) — not because it's required. Use whichever you already pay for. Export or paste your ordered list — item, score, insight count, objective, one-line rationale — into Claude. First the narrative: ``` You are helping me write the narrative for a monthly exec roadmap review. Below is my prioritized roadmap: each item has a score, a linked-customer-insight count, the objective it serves, and my one-line rationale. Write a 6-beat narrative in this order: 1. The decision this review needs from the room (one sentence). 2. What changed since last month. 3. The top 3 priorities, each with the evidence that justifies its rank. 4. What we are explicitly NOT doing this quarter, and what that buys us. 5. The risks I'm accepting. 6. The specific asks. Rules: use only the numbers and rationales I gave you. Do not invent metrics, customer counts, revenue figures, or dates. Where a claim needs a number I haven't supplied, write [NEEDS DATA: ] inline instead of estimating. Keep it under 500 words. Roadmap: """ """ ``` The `[NEEDS DATA]` markers are the useful output. They're a list of the exact holes in your argument, generated before an exec finds them for you. Then, in the same conversation, run the pre-mortem: ``` Now switch roles. You are the most skeptical person in that exec review — a VP whose own priority did not make the top 3. Write the 8 hardest objections this room will raise, ranked by how much damage each does to the decision I'm asking for (most damaging first). For each objection give: - the objection in the words an exec would actually use, - why it lands (what weakness in my reasoning it exploits), - the specific data I would need to answer it — name the metric, the segment, and the time window. Do not invent data I haven't given you, and do not answer the objections for me. If an objection cannot be answered with data at all because it's a values or strategy disagreement, label it POLITICAL rather than dressing it up as an analysis gap. ``` Ranking by damage is what makes this usable — you're not going to answer eight objections in a 30-minute review, and the ranking tells you which three to spend Saturday on. The POLITICAL label matters too: those objections need a pre-meeting with a person, not a chart. ([Pre-mortem before you ship](/prompts/pre-mortem-before-you-ship/) is the same technique aimed at a launch instead of a review.) ### Step 3 — Turn the approved narrative into the deck · [Gamma](/tool/gamma/) Only now does a slide exist. Paste the finished narrative into Gamma and generate — one beat per slide, 8–12 slides, then drop in the Productboard view as the evidence slide. Fix the two or three slides where the generator over-designed a simple point, and stop. See the [Gamma help center](https://help.gamma.app/en/) for paste-and-generate and embeds. **Honest trade-off:** if your company runs on a locked-down corporate template and decks get reused in board packs, generation will cost you more in re-formatting than it saves; [Plus AI](/tool/plus-ai/) works inside Google Slides and respects your template. And if your review is a doc review, skip this step entirely — the narrative from step 2 *is* the artifact. ([Write the exec summary before the slides](/prompts/write-the-exec-summary-before-the-slides/).) ### Step 4 — Pre-answer the top three objections, with real data (40 minutes, not optional) Take the three highest-damage objections from step 2 and go get the actual numbers — the segment breakdown, the churn figure, the support-ticket volume. Put each answer on a backup slide, not in the main flow, and cite the source on the slide. Then apply the rule that makes this playbook honest: **if you cannot answer an objection with data, that's not a slide problem — that's a signal your priority might be wrong.** Go change the order, or go say out loud in the review "we ranked this on judgment, not evidence, and here's the judgment." Both of those end debates. A confident non-answer does not. For anything labeled POLITICAL, book fifteen minutes with that person before the review. The objection you defuse in a hallway never costs you the room. ## Where it breaks - **A pretty deck doesn't fix an un-defensible priority.** Gamma will make a beautiful slide out of a ranking you can't justify, and beautiful makes the challenge sharper, not softer. If step 4 keeps producing unanswerable objections, the output of this playbook is a re-ordered roadmap, not a deck. - **The AI has no idea what's actually happening in your company.** It doesn't know the VP of Sales has a number to hit this quarter, that the mobile team was promised something in a reorg, or that your CEO has a pet feature. It generates the objections an average skeptical exec would raise. The ones that will actually cost you the meeting are political and specific, and you're the only person in the loop who can name them — which is why the prompt makes it label POLITICAL instead of faking an analysis. - **Re-litigation is usually a decision-rights problem wearing a slide-quality costume.** If the same debate returns every month no matter how good your evidence is, nobody in that room knows who actually decides. Fix that instead — [Bain's RAPID](https://www.bain.com/insights/rapid-decision-making/) exists for exactly this, and one named decider plus a written decision log will do more for you than any deck. Tara Seshan's [ongoing stack rank](https://www.lennysnewsletter.com/p/how-to-communicate-tradeoffs-so-leaders) (paywalled) is the lightweight version: keep the ranking visible and continuously shared, so the review is a checkpoint, not a first reveal. - **Stale insight links.** Traceability is only worth something if it's true. A feature linked to 23 insights from eighteen months ago, half of them from churned accounts, is worse than no number at all — because someone will check. Re-verify the links on the top three items each month; that's most of step 1's twenty minutes. - **The pre-mortem becomes theatre.** Running the objection prompt and reading the output feels like preparation. It isn't. The only part that changes the meeting is step 4 — going and getting the data, or changing the priority. Skip it and you've spent two hours making a confident-looking version of the same un-defended roadmap. --- # From a two-week data queue to a same-day decision memo Status: proven. Last verified 2026-07-28. Tested with: Source-checked 2026-07-29; the step 2 (Julius) and step 3 (decision memo) prompts were run against Claude Opus 5 on a sample CSV export. Amplitude's agent UI was not re-exercised in this pass — the step is written against the documented behaviour, including the sampling caveat below. ## The struggle Trial-to-paid conversion dropped four points last month. You need to decide by Thursday whether to pull the onboarding rework forward, and answering that means knowing *which* step, *which* segment, and whether it's real or an artifact of the pricing test. So you file a ticket. It gets triaged into a queue that's two weeks deep behind a finance close and a board deck, and the analyst who eventually picks it up will need a 30-minute call to understand what you meant by "drop-off," then send back a chart that answers a slightly different question than the one you asked. The obvious fix is "learn SQL," and it fails for a boring reason: you don't need SQL, you need one number in the next four hours, and by the time you'd be fluent enough to get it safely you'd also need to know your warehouse's schema, its event tables, and which of the three `users` tables is the real one. So the decision gets made on instinct with a data ticket still open behind it — which is the actual cost, not the wait. This playbook gets you a defensible answer to a bounded question the same day, and is explicit about the questions you should still put in the queue. ## The chain ### Step 1 — Ask the question where the events already live · [Amplitude](/tool/amplitude/) Start in Amplitude, not in a spreadsheet. Build the funnel or retention chart for the question as asked — for a funnel, the ordered steps, the conversion window, and the date range that brackets the change ([building a funnel chart](https://amplitude.com/docs/analytics/charts/funnel-analysis/funnel-analysis-build)). Then ask the agent to do the segment hunting for you, because that's the part that takes an analyst an afternoon: ``` Using my trial-to-paid funnel for the last 90 days: which single step lost the most conversion between the first 60 days and the last 30? Then break that step down by platform, plan, and signup source, and tell me which segment accounts for most of the drop. Show the numbers for each segment, and tell me which events and properties you used. ``` The [Global Agent docs](https://amplitude.com/docs/amplitude-ai/global-agent-overview) are worth two minutes here: the agent builds charts and answers follow-ups from plain language, takes 30–60 seconds per real question, and Amplitude itself tells you to validate anything AI-built before it feeds a decision. Take that literally — before you go further, rebuild the one chart that matters by hand and confirm you get the same number. If they disagree, the agent picked different events than you meant, and everything downstream inherits that error. You're done with this step when you have one anomalous slice: *Android trials on the Team plan, stalling at workspace creation.* **When to skip:** if the chart answers your question outright, stop here and go write the memo. Half of these questions die at step 1, which is the point. And if your events aren't in a product-analytics tool at all — the numbers you need live in the warehouse — swap this step for [get the SQL for a funnel question in plain English](/prompts/get-the-sql-for-a-funnel-question-in-plain-english/) and have an analyst read the query before you run it. ### Step 2 — Interrogate the slice, with the code showing · [Julius](/tool/julius-ai/) Amplitude tells you *where*. It won't tell you *whether the shape is real*. Export the anomalous slice as CSV — user-level rows, with the properties and timestamps you care about — and upload it to Julius ([hands-on walkthrough](https://www.datacamp.com/tutorial/julius-ai-guide)). Then: ``` This CSV is user-level data for Android trials on the Team plan over the last 90 days. Columns are described in the header row; ask me if any are ambiguous instead of guessing. 1. Describe the data first: row count, date range, missing values per column, and any duplicate user rows. Tell me if anything looks truncated or filtered. 2. Compare the last 30 days against the prior 60 on the workspace-creation step, and tell me whether the difference is larger than the week-to-week variation in this data. 3. Break the last 30 days down by signup week to show whether this is a step change on a specific date or a gradual slide. 4. Flag any confounds you can see IN THIS DATA — a cohort that appears suddenly, a property that changes mid-period, an incomplete final week. Rules: show me the code for every step so I can check it. State your assumptions explicitly and label anything estimated or modeled as an estimate. Do not fill in missing values silently, and do not report a difference as meaningful without showing the variation you compared it against. ``` The "show me the code" rule is the entire reason to use a tool like this instead of asking a chatbot to eyeball a table. The code is your audit trail: you can read it, an analyst can read it in ninety seconds, and it's what turns "the AI said" into "here's exactly how this number was computed." If you can't follow the code, that's the signal to ask, not to proceed. ([Analyze a CSV export without a spreadsheet](/prompts/analyze-a-csv-export-without-a-spreadsheet/) is the lighter version of this step.) ### Step 3 — Write the memo the decision actually needs · [Claude](/tool/claude-ai/) > **Any frontier model runs this step.** ChatGPT and Gemini do this job as well as Claude does; the prompt is plain text in, text out. We name Claude because that's what we field-tested with (see *last field-tested* above) — not because it's required. Use whichever you already pay for. Paste the Julius output — findings *and* the code — into Claude: ``` Below is an analysis of trial-to-paid conversion for Android Team-plan trials, including the code that produced it. Write a one-page decision memo for my product leadership. Structure: - The decision on the table (one sentence). - What the data shows — every number cited verbatim from the analysis below. - What the data does NOT say: the questions this analysis cannot answer, and the alternative explanations it does not rule out. - My recommendation, and my confidence in it. - "What would change this recommendation": the specific finding that would flip it. - What I'd need from the data team to be certain, and how long that would take. Rules: every number must appear verbatim in the analysis I gave you — do not round, re-derive, annualize, or extrapolate. If a number I need for the memo isn't in the analysis, write [NOT IN ANALYSIS] rather than supplying one. Label anything the analysis marked as an estimate as an estimate in the memo too. Under 400 words. ``` The "what would change this recommendation" line does more work than it looks like it does. It tells your reader you know the limits of a same-day analysis, and it pre-commits you to changing your mind on a specific trigger instead of defending the memo later. ([Decision memo from an analysis](/prompts/decision-memo-from-an-analysis/) is the standalone prompt.) ### Step 4 — Check every number against source (10 minutes, not optional) Open the memo next to the Amplitude chart and the Julius output, and verify each figure by eye. Three specific checks: 1. **Verbatim, not re-derived.** A percentage that appears in the memo but not in the analysis was computed by the LLM. Delete it or recompute it yourself. 2. **Estimated numbers labeled as estimates.** If sampling was on in Amplitude, your totals and uniques are extrapolations from a 10% user sample, not counts — [Amplitude's own docs say so](https://amplitude.com/docs/analytics/charts/optimize-query-performance). Write "≈" and say why. 3. **The date range is honest.** Truncated final week, timezone boundary, conversion window shorter than your actual sales cycle — any of these produce a real-looking drop that isn't one. Then send the memo to your data team at the same time you send it to leadership, with the Julius code attached and one line: *"decision was today, here's what I did — tell me if I got it wrong."* This is what keeps self-serve from becoming a credibility problem. You're not going around them; you're bringing them a checkable artifact instead of a ticket. ## Where it breaks - **Metric definitions are not yours to change.** Self-serve means answering a question with existing definitions. It does not mean deciding what "active user" means, what counts as activation, or where the trial window starts. Redefine a company metric in a memo and you've created a second version of the number that someone will cite in six months. Emilie Schario's [JTBD piece](https://locallyoptimistic.com/post/building-more-effective-data-teams-using-the-jtbd-framework/) makes the case plainly: metrics management is a data-team job with named business and technical owners. If your answer requires a new definition, that's a queue item, and it always was. - **A modeled number quoted as a fact will cost you more than the two-week wait.** This is the failure that ends self-serve at a company. Query-time sampling extrapolates totals and uniques from a 10% user sample; Julius will happily produce a projection if you don't forbid it. Say "≈2,400, estimated from a 10% sample" in the exec review and you keep your credibility. Say "2,400" and get corrected by an analyst in front of your VP, and you lose the right to run your own numbers. - **Sampling and date-range traps, specifically.** The last period is almost always incomplete and always looks like a decline. A funnel's conversion window silently excludes users who convert later — shorten it and conversion drops, and nothing about the product changed. Timezone boundaries shift day-level counts. Any one of these can manufacture the exact four-point drop you're investigating, which is why step 2's prompt asks about the incomplete final week and step 4 checks the range by hand. - **Unread code is just a confident guess.** If you skip reading Julius's code because it looks plausible, you've reintroduced everything this workflow was supposed to remove — you just got the wrong answer faster and with a chart attached. Nobody downstream can audit what you didn't look at. - **Some questions genuinely need the queue.** Anything joining product events to revenue, contracts, or support systems. Anything that will become a board number or a company KPI. Anything where being wrong is expensive and slow to detect. The point of getting fast at the bounded questions is that the data team's two weeks get spent on the ones that actually deserve two weeks. --- # Turn a user story into testable acceptance criteria Status: proven. Last verified 2026-07-25. Job: Given/When/Then acceptance criteria for one user story — happy path, edge cases, and error states — plus an explicit list of what the model couldn't infer and needs you to decide. --- # Analyze a CSV export without touching a spreadsheet Status: proven. Last verified 2026-07-21. Job: A defensible answer from a messy export in about ten minutes — data-quality flags, the cut you asked for, a chart, and the code that produced it. --- # Build a competitor battlecard in 10 minutes Status: proven. Last verified 2026-07-21. Job: A one-page, sales-ready battlecard for one competitor — positioning, where they win, where you win, landmines, objection handling — built from cited sources you can defend. --- # Ship a clickable prototype from a one-paragraph idea Status: proven. Last verified 2026-07-21. Job: A live, shareable web app with real navigation and persisting data, built from one paragraph. --- # Turn a numbers dump into a one-page decision memo Status: proven. Last verified 2026-07-25. Job: A crisp decision memo from a pile of analysis — the question, what the data says, what it pointedly does NOT say, a recommendation with a confidence level, and the line that would change your mind. --- # Draft a TAM/SAM/SOM market-sizing first pass Status: proven. Last verified 2026-07-21. Job: A structured first-pass market sizing — TAM, SAM, SOM by both top-down and bottom-up methods, as ranges — with every assumption and source laid out to interrogate. --- # Get the SQL for a funnel question in plain English Status: proven. Last verified 2026-07-21. Job: A working funnel query against your real warehouse tables, with the SQL laid out to verify the joins and a shareable notebook link to drop in Slack. --- # Build a positioning one-pager from a competitor's own copy Status: proven. Last verified 2026-07-25. Job: A structured read of a competitor from their homepage and pricing page — claimed value, target, pricing model, and gaps — plus a clear-eyed where-we-win / where-we-lose, with every claim traced to the line it came from. --- # A PRD first draft from a rough idea Status: proven. Last verified 2026-07-06. Job: A structured PRD skeleton — problem, goals, non-goals, requirements, acceptance criteria, open questions — from three sentences in about ten minutes. --- # Turn a PRD into an exec-review deck in 15 minutes Status: proven. Last verified 2026-07-21. Job: A tight 8-slide exec-review narrative deck built from your PRD, argument first. --- # Run a pre-mortem before you ship Status: proven. Last verified 2026-07-25. Job: The eight most likely ways your launch fails, ranked, each paired with the earliest real signal you'd see it coming — so you can watch for it instead of writing the post-mortem later. --- # Red-team your PRD before eng and design do Status: proven. Last verified 2026-07-25. Job: A ruthless critique of a finished PRD from two skeptical reviewers — the holes, bad assumptions, and single riskiest belief — before the people who'll actually build it find them for you. --- # Score a backlog with RICE using AI (without inventing the numbers) Status: proven. Last verified 2026-07-21. Job: A RICE-ranked table of your backlog — Reach, Impact, Confidence, Effort, score, and a one-line rationale per item — with every assumed number flagged for you to verify. --- # Draft a one-page exec update from raw notes Status: proven. Last verified 2026-07-25. Job: A tight, fixed-format exec update — Shipped, Slipped and why, Decisions needed from you, Risks — built only from what your notes actually say, with every guess quarantined so you don't accidentally report fiction upward. --- # Synthesize churn interviews into the real reasons people left Status: proven. Last verified 2026-07-25. Job: Ranked cancellation reasons backed by verbatim quotes and participant tags — with "it's too expensive" excuses separated from the value gaps hiding underneath them. --- # Synthesize a stack of user interviews into themes Status: proven. Last verified 2026-08-11. Job: Ranked themes across multiple interviews, each backed by verbatim quotes with participant attribution — traceable synthesis, not a summary you can't trust. --- # Turn a customer call into owned action items automatically Status: proven. Last verified 2026-07-21. Job: A structured recap — decisions, open questions, and action items each tagged with an owner — ready to paste into your tracker. --- # Turn a PRD into a working demo to test with users Status: proven. Last verified 2026-07-21. Job: A working full-stack demo of your PRD's core flow, testable in the browser before engineering starts. --- # Turn scattered customer feedback into roadmap themes Status: proven. Last verified 2026-07-21. Job: A short list of roadmap themes, each backed by the actual customer quotes that justify it. --- # Generate a weekly async update from your week of meetings Status: proven. Last verified 2026-07-21. Job: A short, skimmable weekly update — decided, in flight, blocked — synthesized from every meeting you had that week. --- # Turn a week of meetings into one decision-and-action digest Status: proven. Last verified 2026-07-25. Job: Every decision and every owned action from a week of notes in one place — with contradictions between meetings flagged — so nothing agreed on Monday quietly dies by Friday. --- # Write the exec-summary narrative before you touch a single slide Status: proven. Last verified 2026-07-21. Job: A five-sentence exec-summary paragraph that becomes both your pre-read and the spine of your deck. --- # airfocus Status: proven. Last verified 2026-08-11. Best for: Modular, scoring-first prioritization when you want a custom weighted framework, not a fixed one ## What it is airfocus is a prioritization-first product platform. Its signature is the Priority Poker / weighted-scoring engine: you define your own criteria (value, effort, reach, confidence, whatever your team argues about) with custom weights, score items, and get an automatically ranked priority list plotted on a value/effort chart. It's modular — you turn on roadmap, feedback, and OKR pieces as needed rather than buying one monolith. ## Our verdict If your pain is specifically "we can't agree on *how* to prioritize," airfocus is the best-shaped tool here. The custom weighted frameworks are more configurable than the one-size RICE fields bolted onto other tools, and the collaborative scoring (everyone scores, the tool reconciles) is a genuinely good way to defuse the loudest-voice problem in prioritization meetings. **Where it falls short:** the pricing has gone opaque — there's no self-serve free tier or even a free trial anymore, only a sales demo, which is a real barrier for a PM who just wants to try it this afternoon. It's also narrower than the feedback-to-roadmap suites, so if you also need deep customer-insight capture you'll be stitching in another tool. ## Get value in 10 minutes 1. Book the demo (there's no self-serve trial), and in it ask to build a Priority Poker scoring board on your own real backlog rather than the canned sample. 2. Define your criteria and weights up front — e.g. Reach ×2, Impact ×2, Confidence ×1, Effort ×2 (inverted) — before scoring anything. 3. Score 10 real backlog items and open the priority chart to see the ranked list and the value/effort quadrants. 4. Invite one teammate to score the same items independently, then compare — the gaps between your scores are the conversation worth having. --- # Aha! Roadmaps Status: proven. Last verified 2026-08-11. Best for: Strategy-linked roadmaps for larger orgs that need goals, releases, and reporting tied together ## What it is Aha! Roadmaps is the heavyweight of the category: a deep suite that connects strategy (goals, initiatives), prioritization, releases, and multiple roadmap views into one governed system. It's built for product orgs that need to show how each feature ladders up to a company objective, and it includes prioritization scorecards, capacity planning, and a large library of roadmap templates. Its AI features and idea-management (Aha! Ideas) are separate paid add-ons layered on top. ## Our verdict When the problem is "our roadmap has to survive an exec review and connect to OKRs," Aha! is hard to beat — the strategy-to-feature linkage and the reporting are more rigorous than anything else here. Its scoring models are proper (weighted, custom-weightable) rather than a single canned RICE field. **Where it falls short:** it's heavy and expensive. There's no free tier, the interface has a real learning curve that solo and early-stage PMs will find like driving a bus to buy milk, and the genuinely useful AI and idea-crowdsourcing capabilities are add-ons that push the real cost well past the sticker price. ## Get value in 10 minutes 1. Start the 30-day trial (no card required) and pick the Product roadmap template rather than starting blank. 2. Enter 2–3 strategic goals for the quarter, then add a handful of features and link each to a goal — this is the move that makes Aha! worth it. 3. Open the prioritization view, turn on a scorecard (set weights for value vs. effort), and let it rank your features. 4. Generate a Gantt-style roadmap filtered to one goal and export it — that single view is what you'll bring to your next leadership check-in. --- # Amplitude Status: proven. Last verified 2026-08-11. Best for: Asking your product analytics questions in plain English when events already live in Amplitude ## What it is Amplitude is a product analytics platform — funnels, retention, user paths, experiments — and its AI features let you ask those questions conversationally instead of building each chart by hand. The AI Assistant turns a plain-English request into a chart, and via MCP you can query your Amplitude data from Claude, Cursor, or your IDE without opening Amplitude at all. For a PM whose events are already instrumented here, it's the shortest route from "I wonder…" to a real cohort chart. ## Our verdict If your product already sends events to Amplitude, its AI layer is the fastest self-serve answer in this whole category — the data model, the funnels, and the definitions already exist, so the AI has something solid to reason over. The free tier is unusually generous (2M events/month forever, with AI included), which makes it a legitimate starting point, not just a demo. **Where it falls short:** the AI is only as trustworthy as your instrumentation — if events are misnamed or properties are inconsistent, it will confidently answer the wrong question, and it won't tell you the underlying data is a mess. And the jump from Free/Plus to Growth is a sales-led, event-volume-priced contract that gets expensive fast at real scale, with pricing you can't see without talking to sales. ## Get value in 10 minutes 1. In an Amplitude project with live events, open the AI Assistant. 2. Ask: *"Show me the conversion funnel from Sign Up to First Key Action to Day-7 Return over the last 60 days."* 3. Check the event names it picked — this is where instrumentation errors surface. Correct it if it grabbed the wrong step. 4. Follow up: *"Break the drop-off between step 1 and step 2 by acquisition channel, and tell me which channel is worst."* Save the resulting chart to a dashboard so it's not a one-off. --- # Basedash Status: proven. Last verified 2026-08-11. Best for: A whole team living in an AI-native BI workspace where plain English is the primary interface ## What it is Basedash is an AI-native BI platform where natural language is the main way you interact — you describe the chart or analysis you want, and it writes the SQL, picks a visualization, and returns a shareable, governed result. Unlike a standalone text-to-SQL box, it's a full workspace: dashboards, alerts, a metrics layer, a Slack app, and an MCP server. It's aimed at a team that wants everyone, PMs included, self-serving against the same governed data. ## Our verdict When it lands, the experience is the cleanest expression of "just ask your database" in this category — governed metrics mean the AI answers from definitions your data team blessed, which sidesteps the usual wrong-join problem better than a raw text-to-SQL tool. If your org is standardizing a whole team on one AI BI surface, it's worth a trial. **Where it falls short:** there's no path in for an individual PM. Pricing starts at $1,000/month for the Startup plan, there's no permanent free tier (only a 14-day trial), and the value only shows up once a data team has connected sources and defined the governed metrics — so it's a team/org purchase, not a tool you quietly adopt on your own. ## Get value in 10 minutes 1. Start the 14-day trial and connect a data source (or ask whoever owns your warehouse to). 2. Ask in plain English: *"Monthly active accounts for the last 12 months, as a line chart."* 3. Check whether it answered from a governed metric or ad-hoc SQL — governed is the whole point; if it's ad-hoc, read the query. 4. Build one shared dashboard your team will actually open, then decide within the trial whether the $1,000/mo is justified by team-wide use, not your use alone. --- # Beautiful.ai Status: proven. Last verified 2026-07-21. Best for: Keeping a non-designer's deck looking clean without fiddling with layout ## What it is Beautiful.ai is built around "smart slides" — templates that auto-adjust their layout as you add or remove content, so alignment and spacing fix themselves. It also generates a starter deck from a prompt via its DesignerBot. The core promise for a PM who isn't a designer: you can't make an ugly slide, because the system rebalances the layout every time you edit. ## Our verdict Solid if your problem is specifically that your decks come out cluttered and misaligned. The auto-adjusting layouts genuinely remove the pixel-nudging tax, and team plans enforce brand rules so a whole PM org stays consistent. It's a dependable, low-effort way to produce a clean deck. **Where it falls short:** there's no free plan at all — the 14-day trial demands a card and auto-bills — and monthly pricing is steep at $45/mo if you don't commit annually. The same smart-template system that keeps slides tidy also fights you when you want a custom layout it didn't anticipate, and its AI generation is weaker at first-draft structure than Gamma. You're paying for design guardrails, not for the smartest narrative help. ## Get value in 10 minutes 1. Start the trial, open **DesignerBot → Create**, and give it your topic plus your key points and numbers as the prompt. 2. Pick from the smart-slide templates for each section — add your content and let the layout rebalance instead of moving anything by hand. 3. Set your brand colors and logo under Brand so every slide inherits them. 4. Present or export to PowerPoint. Note the trial auto-bills — set a reminder to cancel if you're only trying it. --- # Bolt.new Status: proven. Last verified 2026-07-21. Best for: Spinning up a full-stack working demo entirely in the browser, fast ## What it is Bolt.new (from StackBlitz) builds and runs full-stack web apps in the browser — it writes the code, installs dependencies, runs the dev server, and shows you a live app, all without anything installed locally. You can edit the code directly if you want, or just keep prompting. It sits between v0 (frontend only) and Lovable (guided, non-technical) — more capable and more transparent than Lovable, but expecting a bit more comfort with seeing code. ## Our verdict A strong choice when you want a genuinely working full-stack demo and don't mind glancing at the code. Because the whole environment runs live in-browser, what you test is what actually runs — no "it worked in the mockup" gap. The free tier is one of the more usable in this category with a real 1M-token monthly allowance. **Where it falls short:** it's priced in tokens, and tokens scale with your *codebase size*, not just your prompts — so as the project grows, every edit costs more, and a big app can drain tokens alarmingly fast. It also assumes more technical fluency than Lovable; a non-technical PM can get stuck when a build errors and the fix lives in the code. ## Get value in 10 minutes 1. Open bolt.new (no signup needed to start a first project). 2. Prompt the whole app at once: *"Build a simple event-RSVP app: a public page listing upcoming events, an RSVP button that collects name and email, and an organizer page showing who RSVP'd per event. Use in-memory data for now."* 3. Wait for it to install and boot — the live preview appears in the same window. 4. Test the RSVP flow, then ask for one refinement (*"Add a headcount total per event"*). 5. Use the built-in deploy/share option to send a live link to a colleague. --- # Canva (Magic Studio) Status: proven. Last verified 2026-07-21. Best for: Polished, on-brand decks when design quality matters more than raw speed ## What it is Canva is the design tool most of your org already has, and Magic Studio is its bundle of AI features — Magic Design generates a deck from a prompt, Magic Write drafts and rewrites slide copy, and Magic Switch reformats a deck into a one-pager or doc. For a PM, the draw is that it produces the best-looking output of the bunch and holds your brand kit (logo, fonts, colors) so decks come out on-brand without a designer in the loop. ## Our verdict Reach for Canva when the deck is going somewhere polish counts — a board readout, an all-hands, a customer-facing pitch — and you're willing to trade a little speed for a lot of visual quality. Brand Kit plus Magic Design means a genuinely presentable draft, and Magic Switch turning a deck into a one-page summary is a real PM time-saver. The free tier is usable; Pro at $15/mo unlocks the brand kit and the meaningful AI credit allowance. **Where it falls short:** it's a design tool that added AI, not a narrative tool — Magic Design gives you good-looking slides but weaker argument structure than Gamma, so you do more of the "what goes on each slide" thinking yourself. AI usage is metered by credits, and heavy generation days can hit the ceiling on lower tiers. ## Get value in 10 minutes 1. Set up your **Brand Kit** (logo, two fonts, your color hexes) under Brand — this is what makes output usable, so don't skip it. 2. Start a **Presentation**, open **Magic Design**, and paste your update or key points as the prompt. 3. Pick the generated option closest to your structure, then use **Magic Write** per slide: *"Rewrite as one headline and max three bullets, keep the numbers."* 4. When it's done, run **Magic Switch → Docs** to spin the same content into a one-page pre-read to send ahead of the meeting. --- # ChatGPT Status: proven. Last verified 2026-08-11. Best for: The versatile everyday workhorse — drafting specs, quick analysis, and voice-driven interview note capture. ## What it is OpenAI's ChatGPT is the most widely used AI assistant, and for PMs its breadth is the point: custom GPTs for a reusable PRD-writer, voice mode for talking through a problem on a walk, image and file handling, and a huge plugin/tool ecosystem. Most PMs already have access, which makes it the lowest-friction place to start. ## Our verdict An excellent generalist and, for many PMs, the tool they'll actually open because it's already in their workflow. Custom GPTs are the standout for PM work — build a "PRD Writer" once with your template and tone baked in, and share it with the team. Voice mode is genuinely useful for thinking out loud before you write. **Where it falls short:** on very long documents we found it more likely than Claude to drift from the requested structure and to over-confidently fill gaps, so you babysit long PRDs more. The plan matrix is confusing — seven tiers, and the cheap ones now carry ads. Team features that matter (shared workspace, admin) start at Business, which needs a minimum of two seats. ## Get value in 10 minutes 1. Go to **Explore GPTs → Create** and make a GPT named "PRD Writer." In the instructions, paste your PRD template and add: *"Always end with an Open Questions section. Flag assumptions inline. Never invent success metrics — ask instead."* 2. Save it, then start a chat with your GPT and describe the feature in a few sentences. 3. Iterate by section ("tighten the acceptance criteria," "add non-goals") rather than regenerating the whole doc — it holds structure better that way. --- # ChatPRD Status: proven. Last verified 2026-07-21. Best for: A cheap AI copilot that turns a rough idea into a scored, sequenced feature set fast ## What it is ChatPRD is an AI copilot built specifically for PM writing and thinking — best known for drafting PRDs, but equally useful upstream of the roadmap. You give it a rough set of ideas or a problem statement and it will structure them, apply a prioritization framework (RICE, MoSCoW, value/effort) on request, and produce a defensible ranked list with rationale. It runs on premium models (Claude, GPT-4o, o1) and keeps saved templates and project knowledge so its output matches your team's format. ## Our verdict The best value in this category by a distance: for $15/mo it does the reasoning grunt-work of prioritization — turning a messy idea dump into a RICE table with justifications you can edit — that dedicated platforms charge many times more for. For a solo PM or a small team that doesn't need a full feedback-ingestion suite, this plus a spreadsheet covers most of the job. **Where it falls short:** it's a document and reasoning tool, not a system of record — there's no live feedback capture, no shareable interactive roadmap, and no traceability back to real customer quotes. And like every LLM, it will assign confident RICE scores to numbers it invented, so you must supply the real reach/impact data or you're just laundering guesses through a framework. ## Get value in 10 minutes 1. Open the free tier (or Pro for unlimited chats) and paste your raw list of candidate features, one per line. 2. Prompt: *"Score each of these with RICE. Ask me for the Reach and Impact numbers you need instead of inventing them. Mark any score you had to assume with **[ASSUMPTION]**. Output a ranked table with a one-line rationale per item."* 3. Answer its follow-up questions with your real data, then have it re-rank. 4. Ask: *"Now group the top 8 into a 3-part sequence — Now / Next / Later — and explain the dependency or bet behind each grouping."* Paste that straight into your roadmap doc. --- # Circleback Status: proven. Last verified 2026-07-21. Best for: Action items that are accurate enough to trust and auto-route ## What it is Circleback records and transcribes meetings, but its focus is the after-part: it produces the cleanest action items in the category and can fire automations off them — assign a task in Linear, update a CRM record, post to Slack — based on what was actually said. It works across video calls and in-person meetings, with 1,000+ app integrations. ## Our verdict The pick when action items are the whole point. In head-to-head note quality, Circleback's decisions and owned tasks come out sharp enough that you're editing rarely, not always — which is the difference between a tool that saves time and one that just moves the work. The automations are the real unlock: a call can end and a Linear ticket already exists, correctly assigned, before you've closed your laptop. **Where it falls short:** there's no free tier at all — just a 7-day trial — so you can't quietly try it on a few real meetings the way you can with Fathom or tl;dv. At $25/mo for one seat it's also among the priciest for a solo PM. ## Get value in 10 minutes 1. Start the trial and connect your calendar and one destination app (Linear, Notion, or Slack). 2. Let Circleback join your next planning or customer call. 3. After the call, open the notes and check the **Action items** — note how few you need to correct. 4. Build one automation: "When a meeting ends, create a task in Linear for each action item with its assignee." 5. Run it live on your next meeting and confirm the tickets land correctly assigned before trusting it unattended. --- # Claude Status: proven. Last verified 2026-08-03. Best for: Long, structured documents — PRDs, specs, and synthesizing a stack of interviews without losing the thread. ## What it is Claude is Anthropic's AI assistant. For PMs the relevant facts are: it holds very long context (you can paste a whole discovery doc, six interview transcripts, and a competitor's changelog in one go), it's strong at structured writing, and Projects let you keep a standing PRD template and company context so every draft starts from your house style. ## Our verdict Our default for anything document-shaped. It writes the most usable first-draft PRDs of the tools we tested — coherent structure, sensible acceptance criteria, and it flags open questions instead of confidently inventing answers. Artifacts give you a live, editable doc beside the chat, which beats copy-pasting out of a chat log. **Where it falls short:** no built-in web browsing depth for fresh competitive facts unless you turn on search, and like every LLM it will pad a PRD with plausible-sounding scope you didn't ask for — you have to cut, not just accept. It also has no native integration with PM tools like Jira or Linear, so it's a drafting surface, not a system of record. ## Get value in 10 minutes 1. Create a Project called "PRDs" and drop your team's PRD template + a paragraph on your product into the Project knowledge. 2. Start a chat and paste your rough idea plus any constraints ("mobile-only, ships this quarter, no new backend"). 3. Use this prompt: *"Draft a PRD using the template in project knowledge. Mark every place you made an assumption with **[ASSUMPTION]** and list the top 5 open questions at the end. Do not invent metrics."* 4. Answer the open questions in your own words, then ask Claude to fold your answers back in. You'll have a reviewable draft faster than you'd have finished the problem statement by hand. --- # Claude Code Status: proven. Last verified 2026-07-28. Best for: A PM who wants to stop writing tickets for small internal things and just build them — and who can tolerate a terminal. ## What it is Claude Code is Anthropic's agentic coding tool: it reads a folder of files, edits them, runs commands, and checks its own work. It runs in a terminal, in VS Code and JetBrains, in a desktop app, and in the browser at claude.ai/code. The reason it belongs on a PM site has little to do with coding. Three of its features are general-purpose product tooling that happen to ship inside a developer product: **CLAUDE.md**, a markdown file it reads at the start of every session, so your product context stops being something you re-paste; **MCP**, which connects it to Jira, Slack, Figma, Google Drive or your database, so it works from your actual systems; and **skills**, packaged repeatable workflows you can share with a team. ## Our verdict The highest-ceiling tool on this site and the one most likely to change what your job looks like in two years. A PM who can run it can build the internal tool nobody would prioritise, ship a real prototype instead of a Figma of one, and — via MCP — ask questions of Jira and the warehouse in one place. It is also the most honest way to learn what your engineers actually deal with, which quietly improves everything else you do. **Where it falls short:** the terminal is a real wall, and the marketing consistently understates it — if you have never used a command line, budget an uncomfortable afternoon, not ten minutes. There is no free tier, so you cannot try it properly without paying. It will confidently do the wrong thing at speed, which is a different failure mode from a tool that just refuses; you need enough judgment to notice, and on a codebase you don't understand you won't have it. And it is genuinely dangerous pointed at production systems — the blast radius of an agent with shell access is not theoretical. Keep it on scratch repos and internal tools until you know what you're doing. ## Get value in 10 minutes Do not start on your company's main codebase. Start with an empty folder and something small you own. 1. Install it: `curl -fsSL https://claude.ai/install.sh | bash` on macOS, Linux or WSL. Then `mkdir pm-scratch && cd pm-scratch && claude`. 2. Write a `CLAUDE.md` in that folder with five lines about your product: what it does, who uses it, the two constraints that always apply, the words your company uses for things. Every session now starts from that instead of from nothing. 3. Ask for something real and small: *"Read this CSV of support tickets and build me a single-page HTML dashboard showing volume by category over time. No build step — one file I can open in a browser."* 4. Open the file. Ask for the two changes you want. That loop — describe, look, correct — is the whole skill, and it transfers to everything else the tool does. --- # Condens Status: proven. Last verified 2026-07-28. Best for: Small research-minded product teams who want a searchable insight repository without enterprise pricing or an enterprise rollout ## What it is Condens is a UX research repository: you drop in recordings, transcripts, notes and survey exports, then highlight, tag, and cluster them into findings you can share as a linked report. The AI layer handles the mechanical parts — transcription, suggested tags on highlights, session summaries, and asking questions across a whole project — while deliberately stopping short of "press the button and receive your insights." Condens is unusually public about that boundary; it publishes its own survey of 330+ researchers showing AI helps speed far more than it helps quality. ## Our verdict The honest middle option in research repositories. It does the same core job as the category leaders — evidence in, tagged quotes out, every finding traceable back to the person who said it — at an entry price a two-person product team can sign off on without procurement. The tagging flow is fast, the analysis board handles affinity-mapping without a detour into a whiteboard tool, and shared reports expand each claim into the clip behind it, which is what makes research survive contact with a skeptical exec. **Where it falls short:** the gap between tiers is brutal — €15/mo to €500/mo billed yearly, with nothing in between, so the moment you need a few collaborators your cost jumps roughly 30x overnight. There is no free plan at all, only a 15-day trial. And it's a smaller vendor with a thinner integration ecosystem than Dovetail: pulling feedback in automatically from support tools or sales calls means more manual export work than you'd like. ## Get value in 10 minutes 1. Start the 15-day trial (no card) and create one project named after a live question you actually have — e.g. *"Why do trials stall at day 3?"* 2. Upload two or three interview recordings and let Condens transcribe while you do something else. 3. Skim the first transcript and highlight as you read. Don't pre-build a taxonomy: tag with the words the *user* used (`too many steps`, `didn't know what to do next`), and treat the AI's suggested tags as something to accept or reject, not something to start from. 4. Open the analysis board, drag highlights into three to five clusters, and name each cluster as a claim rather than a topic — "Users stall because setup needs data they don't have yet," not "Onboarding." 5. Share the report link into the channel where the decision gets made. The point is the click-through: every claim opens the clip of a real person saying it. --- # Dovetail Status: proven. Last verified 2026-08-03. Best for: A solo PM who wants one durable, searchable research project for free — the team tier now means a sales call. ## What it is Dovetail is a dedicated user-research platform. You upload recordings or transcripts, and it transcribes, lets you tag and highlight quotes, clusters them into themes, and turns findings into shareable insights. AI features add automatic summaries and semantic search across everything you've ever collected. ## Our verdict Still the best tool here when research needs to be durable rather than disposable. The difference versus pasting transcripts into an LLM is the repository: six months later you can search "pricing objections" across every study and get tagged, sourced quotes, not a hallucinated summary. AI summaries and semantic search meaningfully cut the tagging grind. **Where it falls short:** the pricing page now shows exactly two plans — Free and Enterprise "contact sales." The self-serve **$15/user/mo Professional** tier we recorded in July is gone, and the free plan is capped at one channel and one project. So the moment a second PM needs their own study, your options are a sales call or a different tool — there is no visible price to grow into. That's why the score dropped from 4 to 3 and why it is no longer our pick in this category: the product didn't get worse, the way in did. Verified on the live pricing page 2026-08-03. ## Get value in 10 minutes 1. Start on the **Free** plan and upload two or three interview recordings. Let it transcribe. (One project is the cap — pick the study that matters.) 2. Highlight quotes as you skim and apply a handful of tags (e.g. `pain: onboarding`, `delight: speed`). Don't over-engineer the taxonomy on day one. 3. Open the **Insights** view and let AI cluster your highlights into themes. Export the top insight — with its underlying quotes — straight into your PRD as evidence. That quote-to-decision traceability is the whole point. --- # Equals Status: proven. Last verified 2026-07-21. Best for: Revenue/finance-ops teams who want a live-connected spreadsheet with an AI analyst on top ## What it is Equals is a spreadsheet that connects live to your database and SaaS tools, so cells refresh from real data instead of a stale CSV paste — and it layers an AI analyst on top that can build queries, models, and reports from natural language. Higher tiers even bundle human "Forward Deployed Analysts" who help stand up your first complex models. It sits between a spreadsheet and a BI tool, aimed squarely at revenue and finance operations. ## Our verdict For a RevOps or finance-leaning PM who thinks in spreadsheets but is tired of manual data pulls, the live-connection model is genuinely nice — your familiar grid, but the numbers are current, and the AI can draft the SQL behind a cell. The bundled analyst help on upper tiers is a real differentiator for teams standing up reporting from scratch. **Where it falls short:** the price wall is brutal for the typical PM — plans start at $24,000/year, and there's no free tier, only a tailored trial. It's also positioned for finance/revenue ops, so a lot of its depth (financial modeling, close workflows) is wasted on core product questions. Unless your team already has a real revenue-ops budget, this is the wrong tool in this category to reach for. ## Get value in 10 minutes 1. Book the trial (there's no self-serve free entry) and connect one source — a warehouse table or a SaaS tool like Stripe. 2. In a sheet, ask the AI: *"Pull monthly recurring revenue by plan for the last 12 months into this range."* 3. Confirm the cells are live-connected (refresh and watch them update) rather than a one-time paste — that's the feature you're paying for. 4. Ask the AI to show the query behind the range so you can verify the plan/date logic before anyone models on top of it. --- # Fathom Status: proven. Last verified 2026-07-21. Best for: The most generous free tier for recording and summarizing every call ## What it is Fathom is a meeting bot that joins your Zoom, Google Meet, or Microsoft Teams calls, records and transcribes them, and generates AI summaries with action items and follow-up emails. It's known for the most generous free tier in the category: unlimited recording, transcription, and storage, with AI summaries limited only after five meetings a month. ## Our verdict The easy default if you want to try automated notes without paying. Unlimited recording and storage on the free plan is rare, and the summaries are clean and fast — usually ready before you've left the call. The "Ask Fathom" chat lets you interrogate a call after the fact, and the auto-drafted follow-up email is a genuine time saver for PMs who owe a recap after every customer conversation. **Where it falls short:** the free tier's five-AI-summaries-a-month cap is the catch — you get the recordings, but the summaries you actually want dry up quickly, so regular users land on Premium. And the visible bot joining the call makes it a poor fit for sensitive discovery. ## Get value in 10 minutes 1. Sign up and connect your calendar; Fathom will auto-join upcoming Zoom/Meet/Teams calls. 2. Join your next call — Fathom appears as a participant and records automatically. 3. During the call, click **Highlight** on any moment you'll want later (a customer pain point, a commitment). 4. After the call, open the summary and select the "Action items" section — reassign owners if it guessed wrong. 5. Hit the auto-generated follow-up email, edit the two lines that need a human, and send your recap. --- # Figma Make Status: proven. Last verified 2026-07-21. Best for: Turning an existing Figma design or a prompt into an interactive prototype without leaving Figma ## What it is Figma Make is Figma's prompt-to-prototype layer: it turns a text description — or an existing Figma frame — into a working, interactive prototype or small web app, inside the tool your design team already uses. If your org lives in Figma, the appeal is that your prototype starts from real design components and stays in the same file, comments, and sharing model everyone already knows. ## Our verdict Solid, and the obvious default *if you're already a Figma shop* — the design-to-interactive path and shared workspace save real friction. Standalone, it's less compelling than the pure app builders: you're paying for Figma to get Make, and it's more design-flavored than engineering-grade. **Where it falls short:** Make only runs on Full seats on paid plans (Dev and Collab seats can't use it), so the real cost is a Professional Full seat plus AI credits, not "free." Credits are consumed by every AI action and cap out fast, and overflow pay-as-you-go credits are expensive ($120/mo for 5,000). If your team isn't already on Figma, the ecosystem lock-in is a poor reason to start here. ## Get value in 10 minutes 1. In Figma, open a file on a paid Full seat and start a Make session (or open Make from an existing frame). 2. If starting from scratch, prompt: *"An onboarding flow for a mobile habit-tracker: welcome screen, goal-selection screen, reminder-time picker, and a confirmation screen. Make the buttons navigate between screens."* 3. Or select an existing design frame and ask Make to make it interactive. 4. Play the prototype, tweak the flow in chat, and share via the normal Figma share link so stakeholders comment in-context. --- # Fireflies.ai Status: proven. Last verified 2026-07-21. Best for: Searching across every meeting your team has ever had ## What it is Fireflies.ai is a meeting assistant bot that records, transcribes, and summarizes calls across Zoom, Meet, Teams, and dialers, then files everything into a searchable workspace. Its "AskFred" assistant answers questions across your whole meeting history, and it pushes summaries and action items into Slack, Notion, and CRMs automatically. ## Our verdict The strongest choice when meetings pile up and you need to find things later. The cross-meeting search is the standout — ask "what has this customer said about onboarding across all our calls?" and get a real answer, which no notepad-style tool matches. Integrations are broad and reliable, so recaps land in Slack and action items sync to your CRM without copy-paste. **Where it falls short:** the 2026 move to AI *credits* means the good features meter out — heavy AskFred and summary use burns through your allotment, and the free tier's storage fills in weeks. It's also a bot-in-the-room tool, so it's wrong for confidential discovery. ## Get value in 10 minutes 1. Connect your calendar so Fireflies auto-joins scheduled calls, or add `fred@fireflies.ai` as a guest to a specific meeting. 2. Let it record your next team sync; the transcript and summary appear in your dashboard afterward. 3. Open AskFred and ask: *"Summarize the decisions and list action items with owners from this meeting."* 4. Set up a Slack integration so each meeting's recap auto-posts to your team channel. 5. Use the global search bar to query a topic across every past meeting — confirm it surfaces the right calls before you rely on it. --- # Gamma Status: proven. Last verified 2026-07-21. Best for: Turning a paragraph or a doc into a structured deck in one pass ## What it is Gamma turns text into a presentation. You paste an outline, a chunk of a PRD, or a one-line prompt, and it generates a full deck — sensible slide breaks, headings, bullet hierarchy, and stock imagery — that you then edit like a doc rather than a canvas of floating boxes. For a PM it's the fastest path from "I know what I want to say" to "there's a deck to react to." It exports to PowerPoint and PDF and can pull from an uploaded doc so you're not retyping your own content. ## Our verdict This is our pick for the category. Of everything we tested, Gamma gives you the most usable first draft from raw text: hand it your exec-summary paragraph and it comes back with a coherent slide flow instead of one wall-of-text slide per idea. The card-based editor means fixing structure is a matter of splitting and reordering blocks, not fighting alignment guides. The free tier is enough to judge it before you pay, and $9–18/mo is trivial against the hours it saves. **Where it falls short:** the "Made with Gamma" watermark and weak brand controls on the free tier make free-tier output unfit for a real exec deck — you need at least Plus, ideally a Team seat, to apply your company theme. And the PowerPoint export is decent but not pixel-faithful; if your leadership expects the corporate master template exactly, you'll do cleanup after export. ## Get value in 10 minutes 1. Click **Create with AI** → **Presentation**, and choose **Paste in text** (not "Generate," which invents content). 2. Paste your decision or update as prose — e.g. your exec-summary paragraph plus 3–5 supporting points and the numbers. 3. In the prompt line add: *"8 cards max. One idea per card. Keep my numbers exactly. Do not add slides I didn't give you content for."* 4. Generate, then reorder cards so the ask/decision is card 2, not buried at the end. Apply your theme, export to PowerPoint, and do a final label/number pass by hand. --- # Gemini (Deep Research) Status: proven. Last verified 2026-07-21. Best for: A long, structured competitive brief you don't have to babysit ## What it is Gemini is Google's AI assistant, and its standout feature for this category is **Deep Research**: you give it a topic, it plans a multi-step research path, browses dozens of pages, and comes back minutes later with a long structured report and a source list. For a PM it's the difference between "answer my one question" (Perplexity) and "go build me the whole competitive landscape while I do something else." The 1M-token context on Pro means you can then paste that report plus your own docs and keep working in the same thread. ## Our verdict The best value in autonomous research right now. Deep Research produces a genuinely useful first-pass landscape — competitors, positioning, pricing, recent moves — organized into sections you'd actually put in front of a stakeholder. The free tier gives you 5 Deep Research runs a month, which is enough to decide if it's worth the $19.99 Pro tier (which lifts you to 20 runs a day). It reads more Google-indexed pages than a quick chat query ever would. **Where it falls short:** the reports are long and occasionally padded — you'll cut a third of it, and it sometimes over-weights whatever ranks well on Google rather than the best source. It's also weaker than Perplexity at tight, single-fact answers with clean inline citations; Deep Research is a heavier instrument you wouldn't fire for "what's their current price." ## Get value in 10 minutes 1. Open gemini.google.com and select **Deep Research** from the tools/model picker. 2. Prompt: *"Build a competitive landscape for [my product] in [market]. Cover the top 5 competitors: positioning, target buyer, pricing, notable recent launches, and their single biggest weakness. Cite every claim and flag anything you couldn't verify."* 3. Let it run (a few minutes), then skim the report and open the export to Google Docs. 4. In the same thread, paste your own positioning and ask: *"Where do we win and lose against each of these? Give me one battlecard-style talking point per competitor."* --- # Google Stitch Status: proven. Last verified 2026-07-21. Best for: Free, Gemini-powered UI generation from a prompt, with React export ## What it is Google Stitch is Google's prompt-to-UI tool (it absorbed the former Galileo AI, which Google acquired in 2025). It generates multi-screen app and web UI from a text description or even voice, using Gemini models, and exports both designs and React code. While it lives in Google Labs it's entirely free with generous monthly limits, which makes it a low-risk way to generate concept UI without spending a credit budget. ## Our verdict Solid and, right now, the best price in the category: free, with 350 standard generations a month — enough to actually explore, not just sample. The Gemini-powered generation is fast and the React export is a nice bonus over pure mockup tools. If you just need concept screens to react to, start here before you pay anyone. **Where it falls short:** it's an experimental Labs product, which means no pricing commitment and no guarantee of longevity — paid plans are expected by Q4 2026 and the free generosity will likely shrink, so don't build a team workflow on it. Output is design/UI-grade with code export, not a working full-stack app; the buttons don't do anything until an engineer wires them up. And as a Google beta, expect rough edges and changing behavior. ## Get value in 10 minutes 1. Go to stitch.withgoogle.com and sign in with a Google account. 2. Prompt in standard mode: *"A three-screen expense-tracking app: a dashboard with monthly spend and a category breakdown, an add-expense form, and a list of recent transactions. Clean, modern style."* 3. Regenerate or refine screens you don't like (you have plenty of free generations). 4. Export the React code or the design to hand to a designer/engineer, or share the screens for stakeholder feedback. --- # Granola Status: proven. Last verified 2026-07-21. Best for: Great notes from calls you're actually on, with no bot in the room ## What it is Granola is a desktop notepad that listens to your computer's audio during a call and merges what was said with the shorthand you jot down. There's no bot that joins the meeting — it captures quietly in the background, then rewrites your scrappy notes into a clean summary with decisions and action items the moment the call ends. For PMs it's built for the meetings you're personally in: discovery calls, 1:1s, stakeholder syncs. ## Our verdict Our pick for this category. The no-bot approach is the whole point: nobody sees a "Granola Notetaker has joined" banner, so it works for sensitive discovery and exec conversations where a visible recorder changes the room. The output is genuinely better than transcript-summarizers because it anchors on *your* notes — it knows what you thought was important — instead of guessing from a raw transcript. Action items come out with clear owners, and the built-in chat lets you ask "what did we decide about pricing?" across every meeting. **Where it falls short:** because it captures your machine's audio, it's built for calls you're on, not a delegate that joins meetings for you — and the free tier caps you at 25 notes of history, so any serious daily use pushes you to the Business plan fast. ## Get value in 10 minutes 1. Install the desktop app and grant microphone/system-audio permission (it needs to hear both sides of the call). 2. Start your next call. In the Granola panel, type shorthand as you go — just fragments, "decision: ship mobile first", "AI risk — check w/ legal". 3. When the call ends, hit **Enhance**. Granola merges your notes with the transcript into a structured summary. 4. Pick a template — set the note template to "Action items + decisions + open questions" so every meeting comes out in the same shape. 5. Open the chat and ask: *"List every action item with an owner and a due date if one was mentioned."* Copy that block straight into your tracker. --- # Hex Status: proven. Last verified 2026-07-21. Best for: Turning a plain-English question into checkable SQL against your real warehouse ## What it is Hex is a collaborative data notebook — SQL and Python cells that chain together into a shareable, interactive report. Its AI layer, Magic (and the newer Notebook Agent), writes SQL from a plain-English prompt, explains queries, fixes errors, and can draft whole analysis sections. For a PM the draw is text-to-SQL that runs against your *actual* warehouse tables, then leaves the query sitting right there so you (or a friendly analyst) can verify the joins before anyone acts on the result. ## Our verdict When your question needs live warehouse data rather than a static file, this is the tool that gets you closest to self-serve without flying blind. Magic is genuinely good at first-draft SQL, and because the whole thing is a notebook, the query, the result, and the chart live in one link you can drop in a Slack thread. The Community (free) tier is a real place to learn on. **Where it falls short:** it assumes a connected, reasonably modeled warehouse — if your data isn't already in Snowflake/BigQuery/Postgres with sane table names, Hex has nothing to point Magic at, and you're back to needing a data team. The AI also writes confident SQL against columns it half-understands, so a wrong join or a silent fan-out will produce a plausible, wrong number. Always read the generated query. ## Get value in 10 minutes 1. In Community/trial, connect a warehouse (or use a sample dataset) and open a new project. 2. In a SQL cell, click Magic and type the question: *"Weekly active users for the last 8 weeks, from the events table, deduped by user_id."* 3. Read the SQL it generates — check the table, the date filter, and that it isn't double-counting. Run it. 4. Add a follow-up cell: *"Now break that by signup source and chart it as a line per source."* Share the resulting notebook link instead of pasting a screenshot. --- # Jira Product Discovery Status: proven. Last verified 2026-07-28. Best for: Prioritizing ideas and publishing a roadmap that stays linked to the Jira tickets engineering actually works on ## What it is Jira Product Discovery is Atlassian's prioritization and roadmapping tool for the fuzzy work that happens before a ticket exists. You collect ideas in a project, attach insights (customer quotes, support tickets, sales notes) to each one, score them with custom fields and formulas, and then slice the result into whatever view the audience needs — a matrix for your own decision-making, a timeline roadmap for stakeholders, a list for grooming. Ideas link directly to Jira Software epics, so a roadmap item shows real delivery progress rather than a colored bar someone updated by hand. ## Our verdict Great, and the obvious pick if your engineering team already lives in Jira — the delivery link is the feature nobody else can match, and it removes the recurring chore of manually reconciling your roadmap against what's actually shipping. The pricing model is unusually fair for a category full of $10k contracts: only *creators* (PMs) are billed, everyone else contributes for free, and the free tier for up to three creators is a genuinely workable product, not a demo. Custom formula fields let you build whatever scoring model you already believe in rather than adopting the vendor's. **Where it falls short:** it is not a standalone product. It lives inside Jira, and the delivery-tracking payoff — the main reason to choose it — only materializes if your engineers use Jira Software. There is no public idea portal: customers cannot submit or vote, so you collect feedback elsewhere and paste it in by hand, which is exactly the operational overhead [Productboard](/tool/productboard/) exists to remove. Shared roadmap links are read-only and plain — no external commenting, no branding — and the timeline permits one entry per idea, which breaks down for cross-platform work running at different paces. Reporting and export are basic. The AI here is Atlassian Intelligence sprinkled on top (summaries, field suggestions), not the core of the product — buy it for the structure and the Jira link, not for the AI. ## Get value in 10 minutes 1. Create a free Product Discovery project (up to 3 creators, no card) and skip the templates — make one idea for each of the five things you are currently being asked about. 2. Add two custom fields you'll actually defend: an Impact rating and an Effort rating. Then add a formula field that divides them, so ranking is computed rather than argued. 3. On the two highest-scoring ideas, paste in three real customer quotes each as insights. If you cannot find three, that's the finding — the idea is a hunch, and you should label it one. 4. Switch to the matrix view (impact vs. effort), screenshot it, and bring that to your next prioritization meeting instead of a slide. Then link the top idea to its Jira epic so the view stops needing manual updates. --- # Julius AI Status: proven. Last verified 2026-07-21. Best for: Chatting with a CSV or Excel export and getting charts + stats back, no formulas ## What it is Julius is a chat interface bolted onto a Python data-science runtime. You upload a file — a CSV export, an Excel model, a survey dump — and ask questions in plain English. Behind the scenes it writes and runs pandas/matplotlib code, then hands you back the answer, the chart, and (if you ask) the code it ran. For a PM this is the shortest path from "I have a messy export" to "I have a defensible number," without opening a spreadsheet or pinging an analyst. ## Our verdict This is our pick for the PM who works in files, not warehouses. It handles the annoying middle 80% — deduping, pivoting, correlation checks, cohort splits, quick regressions — in a conversation, and it shows its work so you can sanity-check the logic. The free tier is only good for a test drive; Plus at $20/mo is the real entry point and gives you enough headroom for weekly analysis. **Where it falls short:** the 250-message cap on Plus disappears faster than you expect — a single thorough analysis burns 20–30 messages, so heavy weeks push you toward the $45 Pro tier. And like any LLM-driven tool it will occasionally pick the wrong statistical approach with total confidence; if you don't read the code it generates, you can ship a wrong answer that looks polished. ## Get value in 10 minutes 1. Sign up (free tier is fine to start) and drag in a CSV or Excel export — a product usage dump, a churn list, a pricing survey. 2. Ask the plain question first: *"What are the columns, how many rows, and are there any obvious data quality problems (nulls, duplicates, weird outliers)?"* 3. Then the real one: *"Split users into weekly signup cohorts and show week-4 retention for each. Show me the code you ran and flag any assumptions you made about how to define 'retained'."* 4. Read the code block it returns before you trust the chart. If the "retained" definition is wrong, say so and it re-runs. --- # Lovable Status: proven. Last verified 2026-07-21. Best for: A non-technical PM turning an idea into a working, shareable app with real login and data ## What it is Lovable takes a plain-English description and builds a full working web app — frontend, routing, forms, and a real Supabase backend with auth and a database. You chat with it to refine, and it deploys to a live URL you can send to a user the same afternoon. For a PM, this is the closest thing to "describe the product, get the product" without writing code or booking an engineer. ## Our verdict The best pick here for a PM who isn't an engineer and wants a demo people can actually log into and use — not just click through. It handles the unglamorous plumbing (auth, a database table, a working submit button) that turns a mockup into a testable prototype, and the live URL means no local setup for your testers. **Where it falls short:** credits evaporate. Each build or edit spends a credit, and complex logic often needs many rounds, so the 30/month free cap is barely a taste and even Pro's 100 credits vanish in a real project. It also stalls on genuinely complex logic — it'll cheerfully generate something that looks done but breaks on edge cases, and the true cost of a production app (Lovable Pro plus Supabase Pro) lands closer to $65–75/mo than the sticker $25. ## Get value in 10 minutes 1. Sign up (no card needed) and start a new project. 2. Paste one prompt describing the whole thing, e.g.: *"Build a feedback-collection app. Users log in with email, submit a short form (title, description, priority dropdown), and see a list of their own submissions. Add a simple admin view that lists all submissions."* 3. Let it build, then click the live preview and test the flow yourself. 4. Ask for one targeted change (*"Add a status field: New / In review / Done, editable only in the admin view"*) to feel how iteration spends credits — this tells you whether to keep going or switch to a design-only tool. 5. Hit Publish and share the URL with a test user. --- # Mixpanel Status: proven. Last verified 2026-07-21. Best for: Fast plain-English product analytics questions when your events are in Mixpanel ## What it is Mixpanel is a product analytics tool built around events and funnels, and Spark is its AI query layer: you ask a question in plain language and it builds the report — funnel, retention, breakdown — for you. It's the direct competitor to Amplitude's AI, with a similar promise for PMs: skip the manual chart-building and just ask. The free tier includes a monthly allotment of Spark AI queries so you can try the conversational path without a contract. ## Our verdict For teams already on Mixpanel, Spark is a real time-saver on the routine "what's the number" questions that used to mean fiddling with the report builder. Pricing is refreshingly transparent for this category — the usage-based Growth rate ($0.28 per 1,000 events) is published, so you can actually forecast cost, which is rare here. **Where it falls short:** the free Spark allowance (30 queries/month) is genuinely small — you'll burn through it in a single afternoon of exploration and then be back to building reports by hand or upgrading. And as with every AI-on-analytics layer, Spark inherits your instrumentation's sins: sloppy event naming produces a clean-looking, wrong answer, and it won't warn you. ## Get value in 10 minutes 1. In a Mixpanel project with live events, open Spark. 2. Ask: *"What's my 4-week retention for users who signed up in the last two months, as a curve?"* 3. Verify it chose the right signup event and retention definition before you screenshot anything. 4. Spend a follow-up query wisely (the free cap is tight): *"Which single event in week 1 most separates retained from churned users?"* — then instrument or double-down on whatever it surfaces. --- # Napkin AI Status: proven. Last verified 2026-07-28. Best for: Turning a paragraph of your own writing into a clean diagram for a slide or doc, without opening a drawing tool ## What it is Napkin AI turns text into visuals. You paste a paragraph — a positioning statement, a system description, a set of quarterly milestones — highlight it, and Napkin proposes several diagrams for that specific text: flows, matrices, timelines, comparison blocks. You pick one, tweak the labels, colours and icons, and export as PNG, SVG, PDF or PPT. There is no prompting: the input is your writing, which is exactly why it fits a PM's workflow rather than adding a new one. A separate Napkin Slides product builds whole decks with an agent. ## Our verdict A small tool that removes a specific, recurring humiliation: the ugly hand-drawn box diagram in an otherwise good doc. Because it works from your prose rather than a prompt, the output stays anchored to what you actually wrote instead of drifting into generic AI shapes, and the results are properly editable vector objects — not an image you have to redo when a label changes. The free tier is genuinely usable for a PM who needs a few diagrams a week, and SVG export means the diagram survives being resized into a deck. **Where it falls short:** it is a nice-to-have, not a system of record — it holds no data, connects to nothing in your stack, and every visual is a one-off you'll manually redo when the underlying plan changes. The AI is good at generic structures (steps, quadrants, hierarchies) and much weaker at anything with real precision — dense architecture diagrams, anything requiring exact relationships or many nodes come out oversimplified, and you'll fight it. Free-tier visuals carry Napkin branding, and the free allowance resets weekly rather than monthly, so a heavy Monday can leave you empty on Tuesday. ## Get value in 10 minutes 1. Sign up free at app.napkin.ai (desktop only — it won't let you create an account on a phone). 2. Paste the actual paragraph you're struggling to illustrate. A good one to start with: the three-step user journey from your current PRD, written as plain sentences. 3. Select that text and click the spark icon. Skim the proposed visuals and pick the one whose *structure* matches your argument, not the prettiest one. 4. Edit the labels down to three or four words each, swap the colour set to something close to your brand, and delete any decorative icon that doesn't carry meaning. 5. Export as SVG for a deck or PNG for a doc, then paste it above the paragraph it came from — the diagram and the prose should agree, which is the one check people forget. --- # Notion AI Status: proven. Last verified 2026-08-03. Best for: Teams already living in Notion who want AI drafting and Q&A right inside their existing docs. ## What it is Notion AI is the assistant built into Notion. It drafts and edits inside the page you're already in, and **Ask Notion** answers questions across your whole workspace — "what did we decide about onboarding in Q1?" — which is its real superpower for PMs whose specs, notes, and roadmap all live in Notion. ## Our verdict If your team's PRDs already live in Notion, this is the least-friction AI you can adopt — no copy-pasting between apps, and workspace-wide Q&A turns your scattered docs into something you can actually interrogate. The drafting is solid for structure and cleanup. **Where it falls short:** as a pure writing model it's a notch below Claude and ChatGPT on long, reasoning-heavy drafts. The pricing changed meaningfully — the old standalone $10/member add-on was retired, so full AI now effectively requires the **Business** plan, and the newer Custom Agents bill by credits, which makes cost harder to predict. If you're not already a Notion shop, it's not a reason to switch. ## Get value in 10 minutes 1. Open the doc where your specs live and hit **Ask Notion**. Ask it to summarize the last three PRDs into a one-page pattern of "things we keep getting wrong." Instant retro material. 2. On a new PRD page, type `/AI` and prompt: *"Draft a PRD skeleton with sections: Problem, Goals, Non-goals, Requirements, Open Questions. Pull any relevant context from this workspace."* 3. Because it can see your workspace, it'll reference real prior decisions — verify those citations before trusting them. --- # Otter.ai Status: proven. Last verified 2026-08-03. Best for: Capturing and transcribing interviews and calls in real time, then handing clean text to your synthesis tool. ## What it is Otter.ai is a real-time transcription assistant. It joins your Zoom/Meet/Teams call (or records in the room), produces a live speaker-labeled transcript, and generates an automated summary and action items. Think of it as the *capture* layer that feeds whatever you use for synthesis. ## Our verdict The reliable workhorse for getting a clean, speaker-attributed transcript with near-zero effort — it just shows up to the call and does its job. For a PM running user interviews, that transcript is the raw material everything else depends on, and Otter's is consistently usable. Pairs perfectly with an LLM: capture in Otter, synthesize in Claude/ChatGPT. **Where it falls short:** it captures, it doesn't really *analyze* — the auto-summaries are serviceable but shallow, so you'll still do the thinking elsewhere. The free tier's 300 minutes/month disappears fast if you do real research, and accuracy dips with heavy accents, crosstalk, or jargon. Always spot-check quotes against the audio before you cite them. ## Get value in 10 minutes 1. Connect Otter to your calendar so it auto-joins your next interview call. 2. After the call, open the transcript and use Otter's summary only as a table of contents — jump to the moments that matter. 3. Export the full transcript and paste it into your LLM with: *"Here's a user interview transcript. Pull the top 5 pain points, each with a verbatim supporting quote and the approximate timestamp."* Capture + synthesis, split across the two tools each does best. --- # Perplexity Status: proven. Last verified 2026-07-21. Best for: Fast, cited competitive facts you can defend in a review ## What it is Perplexity is a search-first AI that answers a question and shows you the sources inline, with numbered citations you can click. For a PM that's the whole point: when you ask "what did Competitor X ship this quarter" or "how is this market segment sized," you get a synthesized answer plus the links to verify it. Focus mode and the Comet browser let you scope a query to academic sources, a specific site, or a live page. ## Our verdict Our default for competitive and market research, and the tool we reach for first in this category. It hits the sweet spot most PMs actually live in — fast, cheap, cited, with a free tier that's genuinely usable for a few queries a day. Unlike a raw LLM it won't hand you a confident paragraph with no provenance, so you can drop its answers into a roadmap doc and stand behind them. The $20/mo Pro tier unlocks the stronger models and higher limits, which is where it earns its keep. **Where it falls short:** it's a research assistant, not a monitor — it answers the question you ask right now and forgets it. There's no continuous competitor tracking, no alerting, no battlecard store. And it will occasionally cite a low-quality SEO blog with the same confidence as a primary source, so you still have to glance at the domains before you trust a number. ## Get value in 10 minutes 1. Go to perplexity.ai and set the mode to **Web** (or Academic if you want harder sources). 2. Paste: *"List everything [Competitor] shipped or announced in the last 6 months. For each: date, what it is, one line on why it matters, and a source link. Only include items you can cite to the company's own site, changelog, or a named news outlet."* 3. Follow up with: *"Now which of these overlap with [my product's] roadmap, and where are they still weaker than us? Cite each claim."* 4. Copy the cited items straight into your competitive tracker and click through the two or three sources you'll actually quote. --- # Plus AI Status: proven. Last verified 2026-07-21. Best for: AI decks that stay inside Google Slides (or PowerPoint) and your existing template ## What it is Plus AI is an add-on that runs *inside* Google Slides and Google Docs (and has a PowerPoint version), rather than being a separate app you export out of. You generate or rewrite slides from a prompt or an uploaded doc, and the output lands directly in a native Slides file — same theme, same master, same place your team already comments and collaborates. For a PM whose whole company lives in Google Workspace, that "no export step" property is the entire pitch. ## Our verdict The right choice when the deck has to open in Google Slides and match a template your design team already built. Because it edits native slides, you skip the round-trip cleanup that separate-app tools force on you, and its "rewrite this slide" and "remix layout" tools are genuinely useful for tightening a deck you already started. Team-level plans let you upload your own templates so generation respects your brand from the first draft. **Where it falls short:** there's no permanent free plan — after a 7-day trial that requires a card, you're paying, and the good stuff (document uploads, custom templates) sits behind the Pro and Team tiers. The raw text-to-deck first draft is also a notch behind Gamma's on structure; Plus AI shines more as an editor of existing Slides than as a from-scratch generator. ## Get value in 10 minutes 1. Install **Plus AI for Google Slides** from the Workspace Marketplace and open a blank deck built on your company template. 2. Open the Plus AI panel → **New presentation from text** and paste your update or PRD summary. 3. Pick your existing template layout so generation inherits your brand, then prompt: *"One point per slide, keep my metrics verbatim, use the template's existing layouts only."* 4. Use **Rewrite** on any slide that's too dense to cut it to a single headline plus three bullets. The file is already a shareable Slides link — no export needed. --- # PostHog Status: proven. Last verified 2026-07-28. Best for: PMs on a product-led team who want to ask a data question in English and get the SQL, the chart, and the session replay behind it in one place ## What it is PostHog is an all-in-one product analytics platform — events and funnels, session replay, feature flags, experiments, surveys and a SQL-queryable data warehouse under one login. For a PM, the AI angle is PostHog AI: an agent that lives inside your project, answers questions in plain English, builds the insight, writes the SQL when the question outgrows the UI, and shows you what it did. The whole thing is open source and self-hostable, and the cloud free tier is large enough that most small products never pay. ## Our verdict The best value in this category by a distance, and unusually good for a PM working without an analyst. The reason isn't the AI on its own — it's that one question can travel the whole chain in one tab: ask "where does signup drop off," get a funnel, then watch three session replays of the exact users who dropped, then ship a feature flag to fix it. Usage-based pricing with no per-seat fee means you can give the whole team access, which quietly matters more than any single feature. PostHog AI writes readable SQL and leaves it visible, so you can check the work. **Where it falls short:** usage-based pricing is only cheap while your volume is small — a high-traffic consumer product can run a startling bill from session replay and events, and the cost is much harder to forecast than a flat per-seat plan (set billing limits on day one). The platform is also sprawling and engineer-flavoured: instrumentation, autocapture hygiene and event naming are still your problem, and PostHog AI will happily produce a confident, clean chart from badly named events. The 500 free AI credits a month go quickly once you start exploring. ## Get value in 10 minutes 1. Sign up for PostHog Cloud (free, no card) and install the JS snippet, or open the demo project if you're just evaluating. 2. Open PostHog AI and ask: *"Build a funnel from pageview to signup completed for the last 30 days, broken down by referring domain."* Read the definition it picked before you believe the number. 3. Ask the follow-up that only PostHog can answer in the same breath: *"Show me session replays of users who dropped out of that funnel at the last step."* Watch three of them end to end. 4. Ask it to *"write the SQL for the same funnel"* and skim the query — this is the step that catches a wrong event or a double-count. 5. Before you leave, go to billing and set a spend limit. Usage pricing without a cap is how this tool surprises people. --- # PRDKit Status: proven. Last verified 2026-07-28. Best for: Getting from a one-line idea to a PRD plus wireframes and user flows an AI builder can consume ## What it is PRDKit is a PRD generator with a visual habit. You chat an idea at it — or hand it your product's URL so it can read the existing site — and it produces a structured requirements doc, then keeps going: wireframes, user flow diagrams, screen maps, and launch content like social posts and press releases. Its real differentiator is the export: it emits specs in a format tuned for AI builders (Bolt, Lovable, v0, Cursor), plus copy-paste into Notion, Confluence, or Google Docs. ## Our verdict Solid, and unusually well-aimed at how PMs actually work in 2026: the handoff from spec to AI-built prototype is where most PRD tools drop the ball, and PRDKit treats it as the point rather than an afterthought. The URL-ingest trick is genuinely useful — pointing it at your live product gives it enough context that the first draft isn't generic filler. The free tier's 10 credits are enough to judge it honestly before paying. **Where it falls short:** it's a small, young product and the surface area shows it — several advertised outputs (simulated reviews, press releases, demo scripts, Teams integration) are still marked "coming soon," and the whole thing is credit-metered, so a single messy product where you regenerate the flow five times can burn your monthly allowance fast. The generated wireframes are sketch-grade: fine as a thinking aid, not something you put in front of a design review. And unlike ChatPRD it has no depth of prioritization reasoning — it documents an idea, it does not pressure-test whether the idea is worth doing. ## Get value in 10 minutes 1. Sign up for the free plan and, on the first prompt, give it your product's homepage URL rather than a description — let it pull the context itself. 2. Describe one concrete feature in two or three sentences ("let admins bulk-invite users by CSV, with a preview step before send"). 3. Generate the PRD, then immediately open the user flow view and check the screen list against your real app — it will invent screens you don't have. Delete those before anything else. 4. Fix the acceptance criteria by hand (this is the part only you can write), then hit the LLM-optimized export and paste it straight into [Bolt](/tool/bolt-new/) or [v0](/tool/v0/) to see a clickable version of the flow inside the same session. --- # Presentations.ai Status: proven. Last verified 2026-07-21. Best for: A free, brand-synced deck that exports cleanly to PowerPoint ## What it is Presentations.ai generates a deck from a prompt or a document and leans hard on two things PMs actually care about: a **Brand Sync** feature that pulls your company's colors and fonts from a URL, and clean **.pptx export** available from the free tier. It positions itself as the team-friendly option, with unlimited users even on the free Starter plan. ## Our verdict A reasonable pick when budget is tight and the deck must end up as a real PowerPoint file. Getting Brand Sync and .pptx export on a no-card free plan is unusually generous for this category — most rivals gate export or watermark free output. For a quick internal readout that has to open in your leadership's PowerPoint, it clears the bar. **Where it falls short:** billing is annual-only dressed up as a monthly number ($20/mo means $240 upfront), so there's no true month-to-month if you only need it occasionally. The generated structure is competent but generic — it's more "fill this template" than the sharp, idea-per-card breakdown Gamma produces — so you'll rewrite copy to make it sound like your team and not a template. ## Get value in 10 minutes 1. Sign up for **Starter** (no card), then run **Brand Sync** against your company website so decks inherit your colors and fonts. 2. Choose **Create from text**, paste your update or decision, and prompt for *"one idea per slide, my numbers unchanged, no filler slides."* 3. Reorder so the decision/ask is up front, and rewrite any slide that reads like boilerplate. 4. Export to **.pptx** and open it in PowerPoint to confirm it matches your master before you send it. --- # Productboard Status: proven. Last verified 2026-07-21. Best for: Turning a firehose of customer feedback into a prioritized, stakeholder-ready roadmap ## What it is Productboard is a dedicated product-management platform built around one loop: capture feedback from everywhere (support, sales, interviews, a public portal), let its AI (branded Spark) cluster and tag it into insights, attach that evidence to features, then score and sequence those features into a roadmap you can publish. For a PM it replaces the sprawl of a feedback spreadsheet, a scoring doc, and a slide roadmap with one linked system. ## Our verdict The strongest all-rounder for the core roadmapping job, and our pick here. What sets it apart from a generic backlog tool is traceability: every feature on the roadmap can be clicked back to the actual customer quotes that justify it, which is exactly the ammunition you need when a stakeholder challenges your ranking. Spark's auto-tagging genuinely cuts the grind of triaging hundreds of notes, and the prioritization views (including custom scoring) are flexible without being fussy. **Where it falls short:** it's priced and designed for teams, not solo PMs — the Business tier's 2-maker minimum and the fact that real scoring power sits above the Free plan mean the cheap tiers feel like a demo, and the AI credit system means heavy feedback-analysis months can hit a wall unless you're on a higher plan. ## Get value in 10 minutes 1. Sign up for the Free plan and connect one feedback source you already have volume in (start with a Slack channel or a CSV export of support tickets). 2. Let Spark auto-tag the imported notes, then open the Insights view and sort by tag frequency to see what's actually being asked for most. 3. Create 3–4 features from the top clusters, and on each one attach the underlying insights so the evidence travels with the feature. 4. Add a custom prioritization score (or use the built-in one), rank your features, and drop them onto a timeline roadmap. Share the read-only link in your next planning thread. --- # promptfoo Status: proven. Last verified 2026-07-28. Best for: A PM who wants to turn 'the AI answer feels worse this week' into a number, without asking engineering for anything. ## What it is promptfoo is a command-line tool for testing LLM outputs. You write a config file listing your prompts, the models to run them against, and a set of test cases with assertions — "must contain this", "must not mention a competitor", "must be graded 4+ by another model for tone" — then run `promptfoo eval` and get a pass/fail grid. `promptfoo view` opens a local web UI showing every output side by side, so you can see exactly which cases broke when someone changed the prompt. It is open source under MIT, runs entirely on your machine, and needs no account to start. It's now part of OpenAI and remains open source. ## Our verdict The cheapest way for a PM to stop arguing about AI quality from memory. Once your eval set exists, "the summaries got worse" becomes "seven of forty cases regressed, here they are" — and that changes who wins the conversation. The side-by-side comparison view is the part that earns its place: it makes model and prompt changes legible to people who will never read a diff. **Where it falls short:** it is unapologetically a developer tool. You will be editing YAML in a terminal, and the first hour is genuinely unpleasant if you've never done that — the docs assume a comfort level most PMs don't have. It also only tests what you thought to test: it will happily report 100% pass on an eval set that misses the failure mode your customers actually hit, which feels like safety and isn't. And running LLM-graded assertions costs real API money at volume, since every test case is another model call. ## Get value in 10 minutes 1. Pull twenty real inputs your feature has seen — support tickets, search queries, whatever your model actually receives. Real ones. Invented test cases test your imagination. 2. In an empty folder run `npx promptfoo@latest init --example getting-started`, which writes a working config you can edit rather than starting from a blank file. 3. Replace the example prompt with yours and the example tests with your twenty inputs. For each, write the one thing that must be true of a good answer — start with `contains` and `not-contains` assertions before touching LLM grading. 4. Run `npx promptfoo@latest eval`, then `npx promptfoo@latest view`. Change one word in the prompt, re-run, and watch which cases flip. That grid is the artifact — it's what you bring to the next "is it ready?" meeting. --- # Replit Agent Status: proven. Last verified 2026-07-21. Best for: Building and hosting a real working app when you'll also want to poke at the code ## What it is Replit Agent builds full applications from a prompt inside Replit's cloud IDE — it writes code, installs packages, sets up a database, runs the app, and hosts it on a live URL, all in the browser. Unlike the pure "vibe-coding" builders, it hands you a real development environment underneath, so you (or an engineer) can inspect and edit anything. It's the most powerful and most developer-flavored option in this category. ## Our verdict Solid when your prototype needs to be a *real* hosted app and you want the escape hatch of full code access — Replit will build things the more guardrailed tools won't, and hosting is built in. Good fit for a technical PM or one working shoulder-to-shoulder with an engineer. **Where it falls short:** the credit model is a trap for the unwary — the monthly credits are a *shared pool* covering Agent requests, hosting, database compute, and storage, and once depleted, overage charges accrue with no default spending cap. That means a runaway session or a hosted app with traffic can quietly run up a bill. It's also the least beginner-friendly here; a non-technical PM will hit moments where the fix genuinely requires reading code. ## Get value in 10 minutes 1. Sign up (Starter is free to try; full Agent needs Core). 2. Tell the Agent what to build: *"A team standup app: each user posts yesterday/today/blockers, and there's a page showing today's standup for the whole team. Add simple email login."* 3. Let it scaffold and boot; use the live preview to test. 4. Set a spending cap in billing settings *before* you iterate heavily — do this first so a long Agent session can't surprise you. 5. Share the deployed URL with your team. --- # Savio Status: proven. Last verified 2026-07-21. Best for: B2B SaaS teams centralizing feature requests and prioritizing by real customer/revenue weight ## What it is Savio is a focused feature-request tracker for B2B SaaS. It pulls feedback in from your support and CRM tools (Intercom, HubSpot, Help Scout, Slack) and, crucially, ties each request to the account that asked — so you can prioritize by number of customers, plan tier, or MRR at risk rather than by whoever emailed loudest. It's the feedback-triage half of roadmapping, done narrowly and well. ## Our verdict For a B2B PM drowning in "my biggest customer needs X," Savio is the sharpest tool here. The revenue- and account-weighted prioritization is the feature that matters: being able to say "these 12 requests represent $80k of ARR" turns a subjective argument into a number. It stays cheap because you don't pay for the support reps who log feedback via integrations — only for PM seats. **Where it falls short:** it's a feedback funnel, not a full roadmapping suite — the roadmap output is basic and there's no strategy/OKR linkage or rich timeline view, so you'll still export to another tool to present. There's also no free tier, only a 14-day trial, so you can't sit on it long-term for free. ## Get value in 10 minutes 1. Start the 14-day trial and connect the one support or CRM tool where your feature requests actually pile up. 2. Import recent requests and merge duplicates into single feature entries — Savio surfaces likely dupes for you. 3. On your top few features, attach the customer accounts and their plan/MRR so each request carries revenue weight. 4. Sort your feature list by total MRR (or customer count) attached, and screenshot the top 10 — that revenue-ranked list is the artifact to bring to your prioritization meeting. --- # Semrush Status: proven. Last verified 2026-07-28. Best for: Sizing a competitor's demand and, increasingly, checking how AI assistants describe your product versus theirs ## What it is Semrush is the large, established competitive-intelligence platform for the demand side of a market: what competitors rank for, what they pay for ads, where their traffic comes from, and how big the search demand around a category actually is. Its newer AI Visibility toolkit is what makes it relevant beyond marketing — it tracks how often and how favourably AI assistants mention your brand versus competitors' when someone asks a buying question. For a PM, that's a market-sizing and positioning instrument, not an SEO one. ## Our verdict Useful for a specific, increasingly important question — *is this market real, and who owns the demand in it?* — and now for a second one nobody had a tool for two years ago: what an LLM says about you when a prospect asks. Keyword-gap analysis is a blunt but honest read on which problems competitors are actively courting; ad-copy history shows what messaging they kept paying for, which is the closest thing to a public record of what converted. **Where it falls short:** it's expensive and priced for a marketing team, not a PM — the useful tier starts near $200/month, the modular toolkit structure means the thing you want is frequently a separate line item on top, and the free account's 10 queries a day runs out during a single competitor review. The data is also estimated, not measured: traffic and keyword volumes can be off substantially for smaller sites, and for B2B products where buying happens through sales conversations rather than search, the whole dataset can be close to noise. If your PM question is "what features do they ship," this is the wrong tool — it sees demand, not product. ## Get value in 10 minutes 1. Create the free account (no card) and open **Domain Overview**. Enter your closest competitor's domain and note two things only: estimated organic traffic trend over 12 months, and paid vs organic split. 2. Open the **Keyword Gap** tool. Put your domain in the first slot and two competitors in the others, then filter to "Missing" — keywords they both rank for and you don't. Read them as problem statements, not as SEO tasks; that list is a decent proxy for the jobs your competitors are claiming. 3. In **Advertising Research**, look at the ad copy a competitor has run longest. Long-lived ad copy is tested copy — it's their best guess at what makes a buyer act. 4. If you're evaluating the AI Visibility toolkit on trial, add five prompts a real buyer would type into an assistant ("best tool for X for a small team") and see whose product gets named. That gap is a positioning brief you can act on this quarter. 5. Stop at the 10-query free cap and decide honestly whether the answers changed anything before you spend $200/month on them. --- # Similarweb Status: proven. Last verified 2026-07-25. Best for: Estimating a competitor's traffic, channels, and market share ## What it is Similarweb estimates digital traffic and engagement for any website and app — visits, sources, top pages, audience overlap, and how share is shifting between players in a category. For a PM this is the closest thing to seeing a competitor's dashboard from the outside: you can sanity-check "are they actually growing," find which channels drive their acquisition, and get a defensible top-down input for market sizing. ## Our verdict The go-to when your competitive question is quantitative rather than qualitative. It's genuinely useful for market-share framing and for catching a competitor's growth (or decline) before it shows up in the press. The traffic-source breakdown is the standout — it tells you whether a rival lives on SEO, paid, or direct, which shapes how you'd compete. The free browser extension gives you a taste, but real work needs a paid seat. **Where it falls short:** the numbers are modeled estimates, not truth — directionally reliable for large sites, shaky for small ones, and you should never quote a single figure as fact without a hedge. The free tier is deliberately shallow (headline numbers, no drill-downs), and anything team-sized is quote-led "talk to sales," so budget on real work is opaque until you're in a call. ## Get value in 10 minutes 1. Look up a domain on the free tier first (or install the free Chrome extension) — for a quick "are they growing?" sanity check you often never need to pay. 2. Enter a competitor's domain and open **Traffic & Engagement** → note total visits, trend, and average visit duration. 3. Open **Marketing Channels** to see their SEO/paid/direct/referral split — this tells you where they're vulnerable. 4. Use **Compare** to line up 3–5 rivals on visits and share, and screenshot the trend chart straight into your market-sizing or QBR deck (with a "modeled estimate" caveat). --- # Supernormal Status: proven. Last verified 2026-07-21. Best for: Turning a meeting straight into a doc, deck, or spreadsheet ## What it is Supernormal records and summarizes calls across Zoom, Meet, and Teams, but in 2026 it repositioned around post-meeting *work*: it doesn't just write notes, it drafts the follow-up deliverable — a doc, a slide deck, a spreadsheet of action items — from what happened in the call. Pricing moved to a credit-based model so you can add teammates without paying per seat. ## Our verdict Worth a look if your meetings routinely spawn a document. The "do the next thing" angle is the differentiator — a discovery call that becomes a first-draft one-pager, or a planning session that becomes a task spreadsheet, saves a real step. Notes and action items are competent, and the credit model is friendlier than per-seat pricing for a small team. **Where it falls short:** the credit-based pricing makes it hard to predict what you'll actually pay as usage grows, and the generated deliverables still need real editing before anyone sees them — treat them as rough drafts, not finished artifacts. Core note quality is good, not category-leading. ## Get value in 10 minutes 1. Sign up, connect your calendar, and let Supernormal join your next planning call. 2. After the call, open the summary and check the action items for correct owners. 3. Use a post-meeting action to generate a deliverable: *"Turn this meeting into a one-page summary doc for stakeholders."* 4. Edit the draft — cut anything it inferred that wasn't actually said. 5. Share the doc; keep the raw notes linked so anyone can check it against the source. --- # tl;dv Status: proven. Last verified 2026-07-21. Best for: Free unlimited recording with timestamped highlight clips ## What it is tl;dv is a meeting recorder for Zoom, Meet, and Teams that transcribes calls, generates AI summaries, and lets you clip and share timestamped moments. It leans into the video side — cutting a 30-second highlight of a customer describing a pain point and dropping it into Slack is its signature move. ## Our verdict A solid free option, especially if you share moments rather than full recaps. The highlight-reel workflow is genuinely useful for PMs: instead of telling engineering "the customer was frustrated," you send the 20-second clip. Recording and transcription are unlimited even on the free plan, and multi-language support is strong. **Where it falls short:** the free tier caps AI summaries at 10 a month and locks every integration behind Pro — so if you want notes auto-pushed to Notion, HubSpot, or Slack, the free plan won't do it. Summary quality is fine but not best-in-class; the reason to pick tl;dv is the clips, not the notes. ## Get value in 10 minutes 1. Sign up and connect your calendar so tl;dv joins your calls automatically. 2. Record your next customer call. 3. In the transcript, find a revealing moment, select it, and create a **highlight clip**. 4. Ask the AI for a summary: *"Give me decisions, action items with owners, and the top 3 customer quotes."* 5. Drop the highlight clip plus that summary into your product Slack channel so the team hears it in the customer's words. --- # Userdoc Status: proven. Last verified 2026-07-28. Best for: Turning rough notes — or an existing legacy codebase — into a maintained set of user stories, acceptance criteria, and test cases ## What it is Userdoc is a requirements workspace rather than a document editor. You give it rough bullets, screenshots, a Figma file, or an entire source repository, and it expands them into structured artifacts — epics, user stories, acceptance criteria, non-functional requirements, test cases, personas, and user journeys — held in one versioned store with full change tracking. The pitch it leads with is documenting what already exists: connect a legacy codebase and get functional specs for a system nobody on the current team wrote. ## Our verdict Solid, and the most genuinely *specification*-shaped tool in this category — most AI PRD tools produce a document, Userdoc produces a maintained requirements set with structure you can diff, query, and push downstream. The reverse-engineering angle is the standout: if you have inherited a product with no docs, spending an afternoon here is more valuable than a month of archaeology. The image and Figma context feature is the practical version of the same idea — screenshot the running app, get requirements out. **Where it falls short:** there is no free tier at all, and the 14-day trial is capped at one project and ten requirements, which is barely enough to judge whether the structure fits your team. Pricing per seat ($19–$25) is steep next to the $15 generalists, and the structure it imposes is genuinely opinionated — if your team writes narrative PRDs rather than user stories, you will be fighting the tool. The marketing leans hard on enterprise case-study numbers ("6 weeks to 3 hours") that you should treat as vendor claims, not benchmarks. And its code ingestion produces confident specs for behavior it inferred from code, including bugs — it documents what the system *does*, which is not always what it should do. ## Get value in 10 minutes 1. Start the trial and create one project scoped to a single feature area you actually own — not the whole product, given the 10-requirement trial cap. 2. Skip typing: screenshot three or four screens of your existing app and upload them via Image Context, so the AI works from real UI instead of your description of it. 3. Let it generate stories, then ruthlessly reject the generic ones ("As a user I want to log in") — keep only stories that name behavior specific to your product. 4. On the two or three keepers, generate acceptance criteria and test cases, then read them as an adversary: any criterion that is not measurable, rewrite it by hand. That edited set is your deliverable — paste it into your tracker and see whether engineers ask fewer questions than usual. --- # v0 by Vercel Status: proven. Last verified 2026-07-21. Best for: Generating polished React/Tailwind UI you can hand straight to engineers ## What it is v0 turns plain-English prompts into React + Tailwind components and full page layouts, rendered live and deployable to Vercel in a click. It leans design-and-frontend rather than full backend, and the output is real, clean code — not a throwaway mockup. For a PM working with an engineering team that ships in React, it's the cleanest bridge from "here's the idea" to "here's a component the devs can actually use." ## Our verdict The best choice when your prototype's job is to align on *UI* and then get reused, not thrown away. The generated components are genuinely production-grade code, so a designer or engineer can pick them up instead of rebuilding from scratch — which is more than most builders in this category can claim. **Where it falls short:** it's frontend-first. There's no real backend, so anything needing login, saved data, or business logic won't actually work — it looks live but the buttons don't persist anything. The free tier is stingy too: $5 of credits and a 7-message daily cap means you'll hit the wall fast on a real project, and free users can't buy more credits. ## Get value in 10 minutes 1. Go to v0.dev and sign in with a Vercel account. 2. Prompt with specifics: *"A dashboard page for a SaaS admin: left sidebar nav, a top KPI row with 4 stat cards, a data table of recent signups with status badges, and a filter bar. Use a clean, modern light theme."* 3. Iterate in chat on layout and copy until the screen matches your vision. 4. Copy the component code (or deploy to a preview URL) and drop it into your team's Slack for the design/eng review — you're handing them real code, not a screenshot.