Quick-pick table: top prompts at a glance(10)
25 Best ChatGPT Prompts for Product Managers: the top prompts and what you get from each
PromptWhat you get
Define Feature Non-Goals and Scope BoundariesSort requested features into three clear out-of-scope buckets with explicit business reasons to prevent scope creep.
Draft a working-backwards press release and FAQWrite an Amazon-style press release and hard FAQ to clarify customer value and address tough technical questions before writing code.
Turn a Vague Founder Request into a Scoped Problem Brief with Trade-OffsGet a one-page brief that separates the requested feature from the real user problem, compares three options by cost and risk, and names the one question to answer before building.
Transform Customer Interview Transcripts into Ranked Pain-Point MatrixTurn raw interview notes into a structured matrix that ranks customer pain points by frequency and business impact to guide your product roadmap.
Write a Customer Interview Script That Validates a Problem with Past-Behavior QuestionsGet a 30-minute problem-discovery interview script with past-behavior questions, two follow-up probes each, banned-question rewrites and evidence signals.
Write a One-Page PRD for a Small Feature That Engineers Can Start FromGet a one-page PRD under 400 words with one problem statement, one primary KPI, testable requirements, explicit non-goals and an owned open-questions list.
Reframe a feature request into a core user problemBreak down prescriptive feature requests into underlying user motivations, workflow bottlenecks, and testable problem statements.
Stress Test Your Product Requirements Document for Edge CasesThis prompt audits your feature PRD to identify hidden technical risks, permission gaps, and scope creep before development begins.
Prioritize a Feature Backlog Using the Kano ModelSort backlog items into Must-Be, Performance, or Delighter buckets based on user reaction to absence, clarifying which features prevent churn versus drive growth.
Prioritize Your Feature Backlog with RICE Scoring and Flagged Weak AssumptionsGet a ranked RICE scoring table for your pasted backlog, with the math shown, weak assumptions flagged, and a short list of what to build next.

Discovery and user research

6 prompts

Synthesise customer interviews, spot workflow bottlenecks and separate root problems from feature wishes.

  1. #1With example

    Draft a working-backwards press release and FAQ

    Write an Amazon-style press release and hard FAQ to clarify customer value and address tough technical questions before writing code.

    Preview prompt
    Act as a principal product manager applying the working-backwards methodology. Using the raw product idea provided below, write an internal press release and a customer/stakeholder FAQ.
    
    Rules:
    - Write the press release from the future launch date, focusing entirely on customer value and customer quotes rather than internal implementation details.
    - Avoid promotional jargon and hype; state clearly what the product does, who benefits, and why existing alternatives failed.
    - The FAQ must tackle genuinely difficult questions: pricing models, edge cases, technical trade-offs, and operational bottlenecks.
    - Ensure the content strictly reflects the input without fabricating unmentioned company certifications or partners.
    
    Output format:
    - Heading (Future launch date, location, headline, sub-headline)
    - Summary Paragraph (what is launching, for whom, and primary outcome)
    - Problem and Solution Sections (customer pain, status quo failure, product mechanism)
    - Internal Leader Quote and Customer Quote
    - External FAQ (3 hard customer questions with direct answers)
    - Internal FAQ (3 hard operational/engineering questions with direct answers)
    
    My product notes are below:
  2. #2With example

    Write a Customer Interview Script That Validates a Problem with Past-Behavior Questions

    Get a 30-minute problem-discovery interview script with past-behavior questions, two follow-up probes each, banned-question rewrites and evidence signals.

    Preview prompt
    Act as a product researcher who runs problem-discovery interviews for early-stage products.
    
    Write a 30-minute customer interview script that checks whether a problem is real, frequent and painful enough to solve. Before writing, ask me these in one message and wait for my answers:
    1. What problem do you think exists, and for whom?
    2. What do you believe people do about it today?
    3. Who will you interview (role, company size or life situation)?
    4. What decision will this round of interviews inform?
    
    Rules:
    - Every main question asks about past behavior ("Tell me about the last time..."). No hypotheticals ("Would you...", "If we built...") and no leading questions that name the problem or its pain before the interviewee does.
    - Give 2 follow-up probes per question that dig for specifics: dates, time spent, money spent, tools used, who else was involved.
    - Never mention a solution or pitch an idea.
    - Mark which answers count as strong evidence and which are just polite interest.
    - List 5 tempting questions to avoid, each with a past-behavior rewrite.
    
    Output format:
    1. Opening script (under 80 words)
    2. Table: # | Main question | Probe 1 | Probe 2 | What we learn
    3. Questions to avoid → rewrites
    4. Closing script with a referral ask
    5. Signals: strong evidence vs. false positives
    
    End with one line naming the riskiest assumption these interviews cannot test.
  3. #3With example

    Reframe a feature request into a core user problem

    Break down prescriptive feature requests into underlying user motivations, workflow bottlenecks, and testable problem statements.

    Preview prompt
    You are a product discovery specialist. Help me analyze a prescriptive solution request from a stakeholder or customer and extract the root user problem.
    
    Rules:
    - Deconstruct the requested feature into the underlying user goal, trigger, and friction point.
    - Focus on workflow outcomes rather than user interface components.
    - Propose two alternate approaches that solve the real problem without building the exact requested widget.
    - State clearly what customer assumptions need validation.
    
    Output format:
    1. Surface Request: One-sentence summary of what was asked for.
    2. Core User Problem: A standard problem statement (When [trigger], users struggle to [goal] because [blocker]).
    3. Underlying Jobs to Be Done: 2 concise job statements.
    4. Alternative Exploration Paths: 2 lightweight product or workflow alternatives.
    5. Discovery Questions: 3 questions to ask users to validate the problem.
    
    Here is the feature request:
  4. #4With example

    Analyze customer feedback using Jobs to Be Done

    Extract functional, emotional, and social customer drivers from raw user feedback. Use this to separate true user motivations from reactionary feature requests.

    Preview prompt
    Act as a customer research lead. Analyze the user feedback, interview transcripts, or survey responses below using the Jobs-to-be-Done framework.
    - Disregard specific feature suggestions and extract the underlying progress the customer is trying to make.
    - Separate functional jobs from emotional anxieties and social motivations.
    - Identify the current push factors away from existing solutions and pull factors toward new alternatives.
    - List the habits or anxieties holding the customer back from adopting a change.
    Output format:
    - Core Job Statement: When [situation], I want to [motivation], so I can [expected outcome]
    - Functional Dimension: The practical task to complete
    - Emotional Dimension: How the user wants to feel or avoid feeling
    - Social Dimension: How the user wants to be perceived by peers or leaders
    - Forces of Progress: Four bullet points covering Push, Pull, Anxiety, and Habit
    - Key Product Opportunity: 2-3 sentences on the highest-leverage product bet
    Here is the customer feedback:
  5. #5With example

    Draft a Zero-to-One Product Discovery Experiment Card

    Generates a structured, one-page test card with a falsifiable hypothesis, cheap validation test, and numeric kill threshold for new features.

    Preview prompt
    Act as a principal product manager specializing in lean discovery. Your job is to turn an unvalidated product or feature idea into a single-page discovery experiment card.
    
    Ask me 3 brief questions first, one by one or together in a single numbered message, and wait for my response:
    1. What is the target customer segment and the specific problem you want to solve?
    2. What is the proposed solution or feature concept?
    3. What resources or channels do you currently have access to for fast testing?
    
    Rules:
    - State the core falsifiable assumption as: "We believe [user segment] will [perform action] because [underlying motivation]."
    - The test method must be runnable in under 10 business days with zero engineering code (e.g., painted-door test, manual concierge, customer calls, landing page).
    - Specify exact numerical pass and fail criteria, including sample size.
    - Identify one critical failure mode where false positives could mislead the team.
    
    Output format:
    - Hypothesis: (one sentence)
    - Test Method & Setup: (bulleted steps, timeline, and tooling)
    - Metric & Threshold: (target sample size, minimum viable success metric, kill trigger)
    - Primary Risk & Mitigation: (bias or misleading signal to watch for)
    
    End with one brief line on what technical or regulatory unknowns this test does not evaluate.
  6. #6With example

    Draft Multi-Tier SaaS Product Packaging and Feature Matrix

    Generate a clear, competitive feature matrix for your SaaS product that aligns tiered capabilities with specific user upgrade triggers.

    Preview prompt
    Act as a Senior Product Manager. Your task is to design a three-tier SaaS pricing and feature packaging matrix. Before starting, please ask me these 4 questions: 1. What is the core value proposition of the product? 2. What are the three primary user personas? 3. What is the single most common usage metric that drives value or capacity limits? 4. What is the main differentiator for the Enterprise tier? Once I answer, provide the matrix. Follow these rules: 1. Create three tiers: Free, Pro, and Enterprise. 2. Include one unique upgrade trigger metric for each tier transition. 3. Ensure every feature listed in a tier directly solves a specific pain point for that persona. 4. Use a table format with features as rows and tiers as columns. 5. Include a brief rationale for why the upgrade trigger is placed at that specific usage level. This is not professional financial or legal advice; consult a business strategy professional for final pricing decisions.

PRDs and user stories

6 prompts

Write crisp product requirements, non-goals, edge cases and testable acceptance criteria engineering can build from.

  1. #7ClaudeWith example

    Turn a Vague Founder Request into a Scoped Problem Brief with Trade-Offs

    Get a one-page brief that separates the requested feature from the real user problem, compares three options by cost and risk, and names the one question to answer before building.

    Preview prompt
    You are a senior product manager who turns loose founder requests into scoped problem briefs before any design or engineering work starts.
    
    The user will paste the founder request (Slack message, email or meeting note) right after this prompt. If they have not, ask for it plus the following, numbered in one message, and wait for answers:
    1. Who the product serves and roughly how many active users or accounts.
    2. Any data, complaints or deals behind the request.
    3. Team size and weeks available.
    
    Rules:
    - Quote the stated solution word for word, then restate the underlying user problem without naming any feature.
    - Mark every claim as Known (from the input) or Assumed. Do not invent metrics, customer quotes or research.
    - Give exactly three alternative solutions, including at least one that costs under one engineer-week. Rate each on cost in engineer-weeks and risk (Low, Medium or High, with a one-line reason).
    - Define success as one measurable signal with a time window.
    - End with the single question that must be answered before building, and who can answer it.
    
    Output format:
    1. Stated solution
    2. Underlying problem (2-3 sentences)
    3. Known vs Assumed (two-column table)
    4. Options table: Option | What it is | Cost | Risk | Leaves unsolved
    5. Recommendation (max 3 sentences) and success signal
    6. Out of scope (bullets)
    7. The question to answer first
    
    Close with one line naming the biggest gap in the input.
  2. #8ClaudeWith example

    Write a One-Page PRD for a Small Feature That Engineers Can Start From

    Get a one-page PRD under 400 words with one problem statement, one primary KPI, testable requirements, explicit non-goals and an owned open-questions list.

    Preview prompt
    Act as a senior product manager who writes PRDs engineers can start building from the same day.
    
    Your job: write a one-page PRD for a small feature, under 400 words total.
    
    Before writing anything, ask me these four questions in one message, numbered, then wait for my answers:
    1. What is the feature, and which product or screen is it in?
    2. Who is the user, and what are they struggling with today? Share any data, tickets or quotes you have.
    3. What single number should move if this works, and what is it now?
    4. What is the deadline and team size, and what is definitely out of scope?
    
    Rules:
    - One problem statement, two sentences max, describing user pain, not the solution.
    - Exactly one primary KPI with baseline and target; at most two guardrail metrics.
    - At least three explicit non-goals.
    - Requirements are numbered, max seven, each testable as pass or fail.
    - Never invent facts or numbers I did not give; list each gap under Open Questions with an owner role.
    
    Output format:
    A title line naming the feature, then these sections:
    1. Problem
    2. Users
    3. Primary KPI (table: Metric | Baseline | Target | Measured by)
    4. Requirements
    5. Non-goals
    6. Open Questions (table: Question | Owner | Needed by)
    7. Rollout
    
    End with one line naming the biggest assumption or risk in the doc.
  3. #9With example

    Stress Test Your Product Requirements Document for Edge Cases

    This prompt audits your feature PRD to identify hidden technical risks, permission gaps, and scope creep before development begins.

    Preview prompt
    Act as a Senior Staff Engineer. I will provide a PRD for a new feature. Your job is to audit it for technical risks and scope creep. First, ask me these 3 questions: 1. What is the primary user goal of this feature? 2. Is this feature replacing an existing workflow? 3. What is the most critical technical constraint or dependency? Wait for my response, then provide a four-part audit. Rules: 1. Identify silent failure modes where a user might think a task completed but it did not. 2. Define missing permission boundaries for different user roles. 3. List data migration risks or state conflicts with existing database schemas. 4. Explicitly define what edge cases are out of scope to prevent feature bloat. Output format: ## 1. Silent Failure Modes (bulleted list) ## 2. Permission Boundaries (table with columns: Role, Action, Risk) ## 3. Data Migration and State Risks (numbered list) ## 4. Explicitly Excluded Edge Cases (short list) This is not legal or technical architectural advice; consult your engineering lead for final implementation. Wait for my answers to the 3 questions before starting.
  4. #10With example

    Turn a Feature Idea into User Stories with Given/When/Then Criteria

    Get a backlog-ready set of single-outcome user stories with testable Given/When/Then acceptance criteria, size estimates, and flags on stories too big for one sprint.

    Preview prompt
    Act as a senior product manager who writes backlog-ready user stories for agile teams.
    
    I will paste a feature idea right after this prompt. If it does not say who the users are, what problem it solves, or how long our sprints are, ask me up to 3 short numbered questions in one message and wait for my answers before writing anything.
    
    Then break the feature into user stories.
    
    Rules:
    1. Use "As a..., I want..., so that..." with exactly one user type and one outcome. If an outcome contains "and", split the story.
    2. Give each story 2-4 acceptance criteria in Given/When/Then form, each with a clear pass or fail result.
    3. At least one criterion per story covers an error, empty state, or edge case.
    4. Size each story S, M, L or XL. Mark any XL, or anything that would not fit one sprint, as "Too large" and suggest how to split it.
    5. Order stories so the first one delivers a thin, usable slice on its own.
    
    Output format:
    - Summary table: ID | Story | Size | Sprint fit (Yes / Too large)
    - For each story: ID and short title, the story, numbered Given/When/Then criteria, dependencies, split suggestion if flagged.
    - Open questions: up to 5.
    
    End with one line listing the assumptions you made and anything missing that could change scope.
  5. #11With example

    Write a Product Requirements Document from Your Raw Feature Notes

    Turns pasted feature notes into a PRD where each requirement has numbered, testable acceptance criteria and missing details become open questions.

    Preview prompt
    Act as a senior product manager who writes PRDs that engineers and QA can build and test from.
    
    I will paste my raw feature notes right after this prompt. Turn them into a product requirements document.
    
    Rules:
    1. Use only what is in my notes. If a detail is missing or unclear (limits, numbers, user roles, edge cases, metrics), do not guess. Add it to Open Questions.
    2. Number every requirement (R1, R2, R3). Give each one 2-4 acceptance criteria numbered under it (R1.1, R1.2) in Given/When/Then form, each with a clear pass/fail result a tester could check.
    3. One behavior per requirement. Start each with "The system must" or "A user can".
    4. Mark each requirement Must, Should or Could.
    5. Anything my notes exclude or defer goes under Out of Scope.
    
    Output format:
    1. Summary (max 3 sentences: problem, who it is for, expected outcome)
    2. Goals and success metrics (only those in my notes)
    3. Users and main use cases
    4. Requirements: ID, requirement, priority, then numbered acceptance criteria
    5. Out of scope
    6. Open questions (numbered, each tagged Product, Design, Engineering or Legal)
    7. Dependencies and risks
    
    End with one line naming the biggest gap in my notes that would block engineering from starting.
  6. #12With example

    Break a product epic into vertical MVP slices

    Slice large, horizontal engineering epics into thin, end-to-end user stories. Use this during backlog refinement to ship testable customer value every sprint.

    Preview prompt
    Act as a staff product manager. Decompose the product epic pasted below into thin, end-to-end vertical slices that can ship independently.
    - Avoid horizontal slicing such as pure backend, database-only, or UI mockups without functionality.
    - Ensure each slice provides a complete, testable path for a real user, even if initial mechanics are manual or basic.
    - Order the slices chronologically from the riskiest, smallest MVP slice to subsequent iterative enhancements.
    - Include explicit acceptance criteria and what is intentionally omitted for each slice.
    Output format: For each slice, provide:
    - Slice Name and Order
    - User Story: As a [user], I want [action], so that [outcome]
    - Included Scope: Core functionality and UX
    - Excluded Scope: What we explicitly skip for now
    - Validation Signal: How we verify this slice works in production
    Here is the epic to slice:

Roadmaps and prioritization

10 prompts

Score competing bets transparently, align quarterly themes and explain trade-offs clearly to leadership.

  1. #13With example

    Define Feature Non-Goals and Scope Boundaries

    Sort requested features into three clear out-of-scope buckets with explicit business reasons to prevent scope creep.

    Preview prompt
    Act as a principal product manager. Your job is to define strict non-goals and out-of-scope boundaries for a product initiative to stop scope creep before engineering starts.
    
    First, ask me 3 questions and wait for my response:
    1. What is the core problem and primary goal of the feature or project?
    2. What requests, ideas, or nice-to-haves have stakeholders or engineers suggested that feel distracting?
    3. What are your key launch constraints around timeline, technical debt, or team capacity?
    
    After I answer, categorize all out-of-scope items under three strict headings:
    - Category 1: Never-Build (anti-patterns, off-strategy, or low ROI)
    - Category 2: Post-v1 Evaluation (valuable ideas delayed until usage metrics prove demand)
    - Category 3: External Integration or Partner Dependency (delegated outside core build)
    
    Rules:
    - Every excluded item must include an explicit business justification grounded in revenue, development speed, or operational cost.
    - Avoid vague phrasing like 'later'; name the exact trigger needed to reconsider Post-v1 items.
    
    Output format:
    Markdown table with columns: Proposed Feature, Scope Category, Business Justification, Reconsideration Trigger.
    End with a short bullet list titled 'Scope Risks to Monitor'.
  2. #14With example

    Transform Customer Interview Transcripts into Ranked Pain-Point Matrix

    Turn raw interview notes into a structured matrix that ranks customer pain points by frequency and business impact to guide your product roadmap.

    Preview prompt
    Act as a Senior Product Manager. I will provide raw notes from customer interviews. Your job is to extract specific pain points and organize them into a ranked matrix. Follow these rules: 1. Identify distinct user problems, not feature requests. 2. For each problem, extract one verbatim quote from the transcript as evidence. 3. Estimate the business impact as either Low, Medium, or High based on mentioned operational or financial consequences. 4. Tally the frequency of each problem across the provided notes. Output format: Provide a markdown table with columns: Problem Statement, Verbatim Quote, Business Impact, and Frequency Count. Follow the table with a 3-bullet summary of the top priorities based on highest frequency and impact. This is for internal product discovery and does not replace formal user research methodologies.
  3. #15With example

    Prioritize a Feature Backlog Using the Kano Model

    Sort backlog items into Must-Be, Performance, or Delighter buckets based on user reaction to absence, clarifying which features prevent churn versus drive growth.

    Preview prompt
    Act as a principal product manager specializing in feature prioritization.
    
    I will paste a list of feature requests below this prompt. Categorize every item using the Kano Model based on how users react if the feature is missing.
    
    Rules:
    1. Classify each item into exactly one category: Must-Be (table stakes; absence causes outrage, presence is neutral), Performance (linear satisfaction; more is better), or Delighter (unexpected value; absence goes unnoticed, presence creates loyalty).
    2. For each feature, write one concise sentence explaining customer sentiment if the feature is missing.
    3. Identify the recommended implementation sequence: ship Must-Be fixes first to plug churn, allocate majority capacity to core Performance, and pick one high-visibility Delighter.
    
    Output format:
    - Markdown table with 4 columns: Feature Name, Kano Category, Absence Impact, Priority Order
    - Section: Strategic Sequence (3 bullet points outlining what to build first, next, and last)
    - Section: Assumptions & Blind Spots (one short paragraph highlighting data or user segment assumptions made)
  4. #16With example

    Prioritize Your Feature Backlog with RICE Scoring and Flagged Weak Assumptions

    Get a ranked RICE scoring table for your pasted backlog, with the math shown, weak assumptions flagged, and a short list of what to build next.

    Preview prompt
    You are a senior product manager who runs quarterly planning with RICE scoring.
    
    Job: prioritize the feature backlog I will paste right after this prompt. Before scoring, ask me these questions in one numbered message and wait for my answers:
    1. How many users or accounts will each feature reach per quarter, and where does each number come from (analytics, survey, guess)?
    2. How many person-months will each feature take, and who estimated it?
    3. What is this quarter's main goal (e.g., activation, retention, revenue) for judging Impact?
    4. Any deadlines, dependencies or commitments that should override the score?
    
    Rules:
    - Use standard scales: Impact 3, 2, 1, 0.5, 0.25; Confidence 100%, 80%, 50%. RICE = Reach x Impact x Confidence / Effort.
    - Use only my Reach and Effort numbers. If one is missing, mark the feature "missing" and leave it unranked.
    - Flag with ⚠ any score resting on a guess, a single person's estimate, or an Impact you inferred, plus a one-line reason.
    - Show the calculation for every score so I can check it.
    
    Output format:
    1. Scoring table: Rank | Feature | Reach | Impact | Confidence | Effort | Calculation | RICE | Weak assumption
    2. Top 3 to build next, one sentence each on why.
    3. Weak assumptions to validate, with the cheapest way to check each.
    4. Overrides from deadlines or dependencies.
    
    End with one line naming the biggest risk in this ranking.
  5. #17With example

    Score beta readiness for general availability release

    Evaluate qualitative feedback, bug logs, and usage stats to decide if a beta is ready for general availability. Use this to make unbiased release decisions.

    Preview prompt
    Act as a principal release manager. Evaluate beta performance data against general release standards.
    
    Rules:
    - Assess the provided data across 4 pillars: Technical Reliability, Customer Sentiment, Operational Readiness, and Adoption.
    - Score each pillar from 1 (unready) to 5 (fully ready).
    - Highlight critical launch risks and state whether the product should launch, launch with conditions, or hold.
    - List missing verification data before a final release decision is made.
    
    Output format:
    - Readiness Verdict: One sentence with status: Launch, Conditional Launch, or Hold
    - Pillar Evaluation: Markdown table with columns Pillar, Score (1-5), Justification, Key Risk
    - Mandatory Pre-Flight Checklist: Numbered list of required tasks before releasing to production
    
    My beta data is below:
  6. #18With example

    Write a post-advisory board roadmap recap

    Turn raw meeting notes into a crisp follow-up email that shows customer advisory board members how their feedback shaped the roadmap.

    Preview prompt
    Act as an experienced product leader writing a post-meeting recap for a Customer Advisory Board (CAB).
    
    Review the provided meeting notes and write a warm, executive-ready update email to members.
    - Highlight 2-3 key themes heard directly from the board.
    - Map specific feedback points directly to planned roadmap initiatives or investigations.
    - Be explicit about what will not be prioritized right now and why.
    - Keep the tone collaborative, appreciative, and concise.
    
    Output format:
    1. Executive Summary (2-3 sentences thanking members and setting context)
    2. What We Heard vs. What We Are Building (table with columns: Feedback Theme, Product Response, Target Quarter)
    3. Ideas On Hold (bullet points with brief rationale)
    4. Next Steps & Meeting Schedule
    
    Meeting notes are pasted below:
  7. #19With example

    Cluster Support Tickets by Operational Cost and Severity

    Transforms raw support ticket exports into prioritized root-cause engineering clusters ranked by operational support hours wasted.

    Preview prompt
    Act as a principal product operations manager. I will paste raw customer support ticket summaries or logs at the end of this prompt.
    
    Analyze the logs and group individual issues into distinct root-cause clusters. Follow these rules:
    1. Consolidate surface symptoms into technical root causes (e.g., group checkout timeout errors and missing confirmation emails under webhook failure).
    2. Estimate total support cost per cluster by multiplying the ticket count by typical handling time (use 15 minutes per low-complexity ticket, 45 minutes for sync/data issues, 90 minutes for billing/data recovery).
    3. Rank clusters strictly by total operational hours consumed, from highest to lowest.
    4. Write a concrete 1-sentence engineering action item for each cluster without generic advice.
    
    Output format:
    - Summary Table with columns: Cluster Name, Ticket Count, Estimated Handling Hours, Root Cause Hypothesis, Engineering Action Item.
    - Cost Drivers: 2-3 bullet points identifying the single highest operational drag and why it repeats.
    - Missing Data: 1 line stating what logging or telemetry fields are missing to confirm these root causes.
    
    Here are the support ticket logs to process:
  8. #20With example

    Build a Competitor Feature Comparison and Positioning Summary

    Get a feature comparison table with every cell tagged as user-provided or needing verification, plus win/lose points, a positioning statement and a fact-check list.

    Preview prompt
    Act as a senior product manager who builds competitive analyses for sales and leadership teams.
    
    Your job: build a feature comparison and a short positioning summary for my product against its competitors.
    
    First, ask me these questions in one message and wait for my answers:
    1. What is my product, and who buys it?
    2. Which 2-4 competitors should we compare, and which features matter most to buyers?
    3. What do I already know about each competitor (pricing, features, strengths, weaknesses)? I may paste notes or sales feedback.
    4. Who will read this?
    
    Rules:
    - Use only what I tell you. Do not invent features, prices, customer counts or quotes.
    - Tag every table cell: (U) user-provided or (V) needs verification. Anything from your general knowledge is (V).
    - Keep cells short: Yes, No, Partial, or a fact under 8 words.
    - Every positioning point must reference a specific table row.
    - Include where we lose or tie, not only where we win.
    
    Output format:
    1. Comparison table: Feature | My product | one column per competitor | Why buyers care
    2. Where we win (3 bullets)
    3. Where we lose or tie (2-3 bullets)
    4. Positioning statement (2 sentences: for whom, and why us over the main alternative)
    5. Verification checklist: each (V) item and where to confirm it
    
    End with one line naming the biggest gap in the information I gave you.
  9. #21With example

    Extract win and loss drivers from CRM notes

    Turn raw CRM deal records into actionable product, pricing, and sales execution patterns. Use it to prepare roadmap reviews and board updates.

    Preview prompt
    Act as a product operations analyst. Synthesize the provided raw CRM win/loss deal notes into clear decision drivers and recurring themes.
    
    Rules:
    - Separate product feature gaps from commercial, pricing, and sales execution reasons.
    - Group findings by frequency: primary drivers (repeated across multiple deals) versus isolated one-offs.
    - Contrast what won closed-won deals against what killed closed-lost opportunities.
    - Keep insights concise, factual, and strictly based on the text.
    
    Output format:
    - Top 3 Win Drivers (Theme, evidence summary, affected segments)
    - Top 3 Loss Drivers (Theme, product vs. commercial classification, deal impact)
    - Immediate Product Takeaway (One clear priority to unblock pipeline)
    
    CRM deal notes are below:
  10. #22With example

    Decline a stakeholder feature request diplomatically

    Turn down an out-of-scope feature request without burning bridges. Perfect for product managers protecting roadmap focus while maintaining strong stakeholder relationships.

    Preview prompt
    You are an experienced product manager known for clear communication and firm roadmap discipline. Help me write a polite, professional response declining a stakeholder feature request.
    
    Rules:
    - Validate their underlying business goal without committing to their proposed solution.
    - Explain the trade-off clearly, citing current focus on committed quarterly goals.
    - Provide an alternative path, such as an existing workaround or logging the context for future planning cycles.
    - Keep the tone respectful, collaborative, and decisive.
    
    Output format:
    1. Direct Email Response: A ready-to-send draft under 150 words.
    2. In-Person Talking Points: 3 bullet points for a 1-on-1 conversation.
    3. Follow-Up Action: One sentence describing what documentation or tracking to update.
    
    Here is the stakeholder request and context:

Launches and product metrics

3 prompts

Define experiment guardrails, diagnose funnel drop-offs and turn technical changes into customer-friendly release notes.

  1. #23With example

    Define beta cohorts and launch exit metrics

    Build a structured cohort plan and clear release criteria for your upcoming beta launch. Use this to prevent feature creep and ambiguous testing timelines.

    Preview prompt
    Act as a senior technical product manager. I need to define cohort selection criteria and quantitative exit metrics for a product beta.
    
    First, ask me 3 brief questions in a single message:
    1. What is the core feature or product being tested in beta?
    2. What is your estimated timeline or customer scale for this test?
    3. What primary technical or business risk are you trying to validate?
    
    Wait for my answers. Once I answer, define:
    - 3 distinct user cohorts (size, profile traits, and what each validates)
    - Hard exit criteria across stability, adoption, and customer satisfaction
    - A list of automatic disqualifiers that trigger a rollback or pause
    
    Output format:
    - Cohort Matrix: Markdown table with columns Cohort Name, Target Profile, Size, Core Focus
    - Graduation Scorecard: Bulleted list with explicit metric targets and timeframes
    - Red Flags: Bulleted list of stop-ship conditions
  2. #24With example

    Draft an Internal Launch FAQ and Enablement Brief for Sales and Support

    Turns your launch notes into a sales and support brief with talk tracks, a plain-answer FAQ, objection handling, and flags for claims that need legal or engineering sign-off.

    Preview prompt
    You are a product marketing manager who runs internal launch enablement for B2B software teams.
    
    Your job: turn the launch material I paste after this prompt (PRD, release notes, pricing notes or rough bullets) into an internal launch FAQ and enablement brief for sales and support. If the material does not say who gets the feature, when it ships, or what it costs, first ask me up to 3 numbered questions in one message and wait for my answers.
    
    Rules:
    1. Keep every answer to 3 sentences or fewer, in words a rep could say out loud to a customer.
    2. Cover at least 5 objections and 5 edge cases (plan limits, migrations, permissions, regions, what changes for existing users).
    3. Mark every claim about security, compliance, performance, pricing or dates as needing Legal or Engineering sign-off.
    4. If my material does not answer a question, write "Unknown, confirm with PM" instead of guessing.
    5. Do not invent customer quotes, statistics or benchmarks.
    
    Output format:
    1. Launch summary: one paragraph (what, who, when, why it matters)
    2. Talk track: 3 bullets for sales, 3 for support
    3. FAQ table: Question | Plain answer | Sign-off needed (Legal, Engineering or None)
    4. Objection table: Objection | Response | Sign-off needed
    5. Escalation paths: which questions go to whom
    
    End with the assumptions you made and the open gaps that block launch readiness.
  3. #25With example

    Write a Go-to-Market Launch Plan with Owners, Dates and Go/No-Go Criteria

    Get a tiered launch plan with a T-minus timeline, one owner role per task, measurable go/no-go criteria, an hour-by-hour launch-day checklist and week-one metrics.

    Preview prompt
    You are a senior product marketing manager who has run launches of every size.
    
    Build a go-to-market launch plan for my launch. First ask me these questions in one numbered message and wait for my answers:
    1. What are you launching: a small update, a notable feature, or a major release?
    2. Who is the audience (segment, new or existing customers, rough size)?
    3. What is the launch date, and is it fixed?
    4. Which teams and channels can you use?
    
    Rules:
    - Assign a launch tier (1 = major, 3 = minor), justify it in one sentence, and scale the plan to it.
    - Every task has one owner role (PM, PMM, Eng Lead, Support Lead), never a whole team, and a T-minus date.
    - Go/no-go criteria are measurable or yes/no (e.g., 'open P0 bugs = 0') and each names a decider.
    - Include a rollback trigger and three week-one metrics with targets.
    - Don't invent statistics or benchmarks; label any number I didn't give as an assumption.
    
    Output format:
    1. Launch summary: tier, audience, date, goal
    2. T-minus timeline table: When | Task | Owner role | Done when
    3. Go/no-go table: Criterion | Threshold | Decider
    4. Launch-day checklist, hour by hour
    5. Week-one metrics and rollback trigger
    
    End with one line naming the biggest risk and any missing information.

Playbook

How to get better results

Which AI model to pick

Claude
Synthesising lengthy user research transcripts and drafting coherent PRDs with thorough edge cases.
ChatGPT
Prioritization frameworks, rapid user story splitting and live editing of specs in canvas.
Gemini
Cross-referencing competitive product documentation and exporting briefs into Google Docs.

Follow-up prompts to refine any output

  1. Add an explicit Non-Goals section and list the top three technical or adoption risks that could derail this release.
  2. Rewrite every user story above with concrete acceptance criteria covering empty states and permission errors.
  3. Turn this spec into a half-page executive summary highlighting the user problem, expected metric shift and open decisions.

FAQ

About this list

Strong product docs depend on real context rather than boilerplate templates. Each prompt asks you to paste what you already have: user interview notes, support ticket clusters, usage metrics or engineering constraints. From that evidence, the assistant extracts recurring pain points, drafts scoped requirements and highlights open risks before anyone writes code.

The list spans the full product cycle, from problem framing and prioritization matrices to stakeholder updates, experiment plans and clear release notes written in plain customer language. Every prompt shows an example document so you can inspect the level of detail before copying, and runs in ChatGPT, Claude or Gemini. Fill in any blanks on the page first so the spec opens ready to review.

What should I paste to get a useful PRD instead of filler?

Paste the customer problem statement, real user quotes or support examples, non-goals, technical constraints and the single metric you expect to move. When a PRD prompt receives real trade-offs and boundaries, it writes specific user stories, edge cases and acceptance criteria instead of generic feature wishes.

Can these prompts synthesise multiple customer interviews at once?

Yes. Paste anonymised transcripts or structured notes from several calls and label each speaker by segment. The discovery prompts group themes by frequency, separate stated feature requests from underlying workflow pain and quote exact lines so stakeholders can verify every takeaway against the raw notes.

How do product teams keep sensitive roadmap data safe in AI tools?

Remove customer names, account identifiers, revenue totals and unreleased partner names before pasting into a public chat window, or use your company's approved workspace with training disabled. Product prompts only need the workflow shape, relative impact and constraints to produce strong specs and prioritization tables.

Which AI assistant works best for product specs and roadmaps?

Claude shines when you paste long research transcripts, old specs and strategy memos together and need a cohesive, carefully reasoned PRD. ChatGPT is fast for prioritization matrices, stakeholder summary slides and iterating on acceptance criteria in canvas. Gemini integrates nicely when your team stores briefs in Google Docs.