20 ChatGPT-5.5 Prompts for Product Managers — Roadmap Planning, User Story Writing, Competitive Analysis, and Sprint Retrospectives
20 Advanced ChatGPT-5.5 Prompts for Product Managers — A Practical Playbook (July 2026)
As of July 2026, ChatGPT-5.5 is a production-ready assistant capable of deep, structured reasoning and long-form outputs tailored to product workstreams. This article delivers 20 ready-to-use prompts specifically crafted for Product Managers: 5 for roadmap planning, 5 for user story writing, 5 for competitive analysis, and 5 for sprint retrospectives. Each prompt includes the exact copy-paste prompt text, guidance on when to use it, the expected output format, pro tips for customization, and a representative example output snippet. Use these prompts as templates you can feed directly into ChatGPT-5.5 (or adapt for internal copilots). Where helpful, I’ve included JSON and API-ready blocks, comparison tables, and practical code examples for automation and integration.
This resource is intended for PMs working with engineering teams, data teams, design, and GTM partners. It assumes familiarity with common product frameworks (RICE, ICE, OKR), agile ceremonies, basic SQL/JSON, and a focus on measurable outcomes. Integrate these prompts into your workflow tools (Notion, Confluence, Jira) via automation or use them interactively for planning sessions, stakeholder documents, and quick analysis.
Internal references for further reading:
For a deeper exploration of ChatGPT prompting techniques, our comprehensive guide on OpenAI Unifies ChatGPT and Codex Into a Single Desktop App — What Changes for Users in July 2026 provides detailed walkthroughs, practical examples, and expert recommendations that complement the strategies discussed in this section.
,
Teams implementing these workflows will benefit from understanding the foundational concepts covered in our detailed analysis of How OpenAI’s $30 Billion Revenue Target Is Reshaping the AI Industry: From Research Lab to Enterprise Platform, which examines the technical architecture and best practices for production deployments.
,
The techniques described above build upon the principles outlined in our in-depth tutorial on 25 ChatGPT-5.5 Prompts for Product Managers: Roadmap Planning, Feature Prioritization, Stakeholder Communication, and Market Analysis, where we examine real-world implementation patterns and performance optimization strategies.
,
Organizations evaluating these capabilities should also review our thorough examination of The GPT-Live Real-Time Audio Playbook — 10 Prompts for Voice Interfaces, Live Transcription, Meeting Summarization, and Conversational AI Prototyping, which covers the enterprise considerations, security implications, and integration pathways relevant to this discussion.
How to use this playbook
- Copy the “full prompt text” verbatim into ChatGPT-5.5 or your enterprise instance, then paste your product-specific context into the designated placeholders.
- Request outputs in JSON when you need to import results into tooling. When crafting stakeholder docs, request markdown or Confluence-friendly text.
- Iterate. The first model pass is often a draft; refine with follow-up prompts that ask the model to prioritize, prune, or adjust tone for audiences (exec, engineering, design).
Section 1 — Roadmap Planning (5 prompts)
Prompt 1: Quarterly Roadmap Generation (aligned to OKRs)
Full prompt text (copy-paste)
You are a senior Product Manager. Given the following context, produce a quarterly roadmap for Q3 2026 that is aligned to the stated OKRs. Output a prioritized list of initiatives, each with: initiative name, one-line description, target metric(s) and baseline, expected impact (% delta or absolute), lead owner, key dependencies, estimate (S/M/L), and success criteria. Also include a 2-week rollout plan for the top 3 initiatives and a stakeholder communication blurb for executives. Context:
- Product: {PRODUCT_NAME}
- Target segment(s): {SEGMENTS}
- Core OKRs for Q3 2026: {OKR_LIST}
- Known constraints: {CONSTRAINTS}
- Key dates: {DATES}
Format: Provide JSON array `initiatives` for ingestion and a human-readable markdown roadmap summary. Use conservative estimates and call out assumptions.When to use it
Use this prompt when you must convert strategic OKRs into an actionable quarterly plan, and when you need both machine-readable output for tooling and a narrative summary for stakeholder distribution.
Expected output format
JSON array named “initiatives” plus a markdown “roadmap_summary” string. Example keys: name, description, target_metric, baseline, expected_impact, owner, dependencies, estimate, success_criteria, rollout_plan (array), executive_blurb (string).
Pro tips for customization
- Replace placeholders with concrete numbers (e.g., baseline MRR, DAU) to improve accuracy.
- Add persona constraints (e.g., enterprise customers require security review) to inform dependencies.
- For conservative roadmaps, instruct the model to use 60–70% confidence when estimating impact.
- If you use WSJF or another scoring, ask the model to include a score field and provide weights.
Example output snippet
{
"initiatives": [
{
"name": "Self-Serve Enterprise Onboarding",
"description": "Automated onboarding flow for SMB and mid-market customers.",
"target_metric": "Activation rate (first 7 days)",
"baseline": "24%",
"expected_impact": "+12 percentage points (to 36%) within 90 days",
"owner": "PM - Alex Rivera",
"dependencies": ["Onboarding UX", "API rate limiting review", "Billing integration"],
"estimate": "L",
"success_criteria": "Activation ≥ 34% and NPS onboarding ≥ 55",
"rollout_plan": [
"Weeks 1-2: Feature flagged beta (10% of traffic) + monitor",
"Weeks 3-4: Expand to 50% with iterative tweaks",
"Weeks 5-6: Full rollout + post-release survey"
],
"executive_blurb": "This initiative targets a 12pp increase in activation which should accelerate ARR expansion from self-serve channels."
}
],
"roadmap_summary": "Q3 roadmap prioritizes activation and retention with 3 large initiatives: Self-Serve Onboarding, Usage-Based Billing, and Observability Dashboard..."
}Why this prompt works
The dual-output requirement (JSON + narrative) enables integration with planning tools while producing stakeholder-ready text. Explicit keys reduce ambiguity and speed downstream automation.
Prompt 2: Feature Prioritization Using RICE or ICE
Full prompt text (copy-paste)
You are a product prioritization engine. Given a list of candidate features, score each using both RICE and ICE. For RICE, compute Reach (R), Impact (I), Confidence (C), Effort (E) with numeric inputs or reasonable default assumptions. For ICE, compute Impact, Confidence, Effort. Provide the final ranked list for each methodology and a short explanation (2-3 sentences) when the two ranks diverge. Input:
- Features: {FEATURE_LIST} (each feature: name, short description, estimated reach per quarter, expected impact magnitude (1-5), confidence level (0-100%), effort in person-weeks)
Output format: JSON with keys `rice_scores`, `ice_scores`, `ranked_rice`, `ranked_ice`, and `divergence_notes`.When to use it
Use this prompt during backlog grooming or when reconciling conflicting stakeholder requests to produce a defensible prioritization artifact.
Expected output format
JSON object with arrays for rice_scores and ice_scores, each entry containing numeric breakdown and computed score; ranked arrays should list features by descending score. divergence_notes should explain differences and give a recommended tie-breaker.
Pro tips for customization
- Provide explicit reach numbers (e.g., 5,000 users) for more defensible R values.
- When effort is uncertain, provide high/low ranges and ask the model to produce a Monte Carlo-style expected score (see code example below).
- If your org uses different scales, specify them (e.g., Impact 1–10 instead of 1–5).
Example output snippet
{
"rice_scores": [
{"name": "Feature A", "R": 5000, "I": 3, "C": 80, "E": 4, "score": 3000},
{"name": "Feature B", "R": 2000, "I": 5, "C": 60, "E": 2, "score": 3000}
],
"ice_scores": [
{"name": "Feature A", "I": 3, "C": 80, "E": 4, "score": 60},
{"name": "Feature B", "I": 5, "C": 60, "E": 2, "score": 150}
],
"ranked_rice": ["Feature A", "Feature B"],
"ranked_ice": ["Feature B", "Feature A"],
"divergence_notes": "RICE favors Feature A due to larger reach; ICE favors Feature B due to higher normalized impact and lower effort. Recommend split funding: quick win for Feature B, parallel discovery for Feature A."
}Code example: Monte Carlo for RICE scores
import random
def monte_carlo_rice(feature, n=1000):
scores=[]
for _ in range(n):
R = random.normalvariate(feature['R_mean'], feature['R_sd'])
I = random.normalvariate(feature['I_mean'], feature['I_sd'])
C = random.normalvariate(feature['C_mean'], feature['C_sd'])
E = max(0.1, random.normalvariate(feature['E_mean'], feature['E_sd']))
scores.append((R*I*C)/E)
return sum(scores)/len(scores)Comparison table: Prioritization frameworks
| Framework | Best for | Strengths | Weaknesses |
|---|---|---|---|
| RICE | Customer-scaling impact | Quantifies reach and confidence; good for consumer products | Requires reliable reach data; sensitive to effort estimates |
| ICE | Quick tradeoffs | Simple, fast; good for early-stage decisions | Less nuanced; can overemphasize impact |
| WSJF | Engineering-heavy backlogs | Includes cost of delay; integrates with SAFe | Requires rigorous cost-of-delay inputs |
| MoSCoW | Release scoping | Easy to align with stakeholders | Less quantitative; can be politicized |
Prompt 3: Dependency Mapping and Critical Path Identification
Full prompt text (copy-paste)
Act as a program manager focused on dependencies. Given the following list of initiatives and components, generate a directed dependency graph, identify the critical path (longest path by estimated duration), and list at-risk dependencies (external teams, compliance, third-party). Output: a JSON object with nodes (id, name, duration_days, owner), edges (from_id, to_id), critical_path (list of node ids and total duration), and at_risk_dependencies (explanations). Context: {INITIATIVES_AND_COMPONENTS}When to use it
Use this when planning multi-initiative quarters or launches where cross-team sequencing is a risk (e.g., platform upgrades, security reviews, API contracts).
Expected output format
JSON graph with node and edge arrays, a critical_path array describing nodes in order and summed duration, and a plain-text “mitigation_plan” field with 3 recommended actions to reduce single-point-of-failure risks.
Pro tips for customization
- Supply durations in business days and include earliest available start dates when known.
- Add a “dependency type” attribute for edges (e.g., deliverable, decision, approval) to prioritize risk mitigation.
- For complex programs, ask for a flattened Gantt-ready CSV output to import into project tools.
Example output snippet
{
"nodes": [
{"id": "N1", "name": "Data Migration", "duration_days": 20, "owner": "Eng - Data"},
{"id": "N2", "name": "New API", "duration_days": 15, "owner": "Platform"}
],
"edges": [{"from_id":"N1","to_id":"N2","type":"deliverable"}],
"critical_path": {"nodes":["N1","N2"],"total_duration":35},
"at_risk_dependencies": [
{"node":"N1","risk":"Third-party vendor migration window", "mitigation":"Parallel validation environment"}
],
"mitigation_plan":"1) Create parallel test env; 2) Freeze schema changes two weeks earlier; 3) Assign escalation leads"
}Prompt 4: Stakeholder Alignment Document (One-pager)
Full prompt text (copy-paste)
Write a one-page stakeholder alignment document for the following initiative: {INITIATIVE_NAME} with context: {BUSINESS_RATIONALE}, customer impact: {CUSTOMER_IMPACT}, timeline: {TIMELINE}, decision points: {DECISION_POINTS}, and requested approvals from: {STAKEHOLDERS}. The document should include: executive summary, business case (costs vs benefit), key milestones, risk register (top 5), and a section "what I need from each stakeholder" listing clear asks and timelines. Output in Confluence-friendly markdown with headers and a short subject line for an email to send to stakeholders.When to use it
Use this prompt right before stakeholder reviews or when collecting sign-offs after a roadmap decision. The output is useful for exec summaries and as the basis for decision logs.
Expected output format
Confluence-ready markdown with sections: Executive Summary, Business Case, Milestones, Risks, Approvals & Asks, and an email subject + 2-line body for quick distribution.
Pro tips for customization
- Include quantifiable cost numbers and expected timeline in days or weeks.
- Request separate versions: a two-sentence executive summary and a detailed appendix to satisfy both executives and engineers.
- For regulatory-sensitive initiatives, add a “compliance checklist” bullet list tailored to the jurisdiction.
Example output snippet
## Executive Summary
Implement billing migration to usage-based model to unlock 20% ARR expansion in FY27.
## Business Case
Estimated engineering cost: $120k; expected ARR uplift: +$300k/year.
## What I need from each stakeholder
- Legal: Provide contract amendment template by Aug 10.
- Finance: Confirm pricing tiers by Aug 7.
- Sales: Provide 5 pilot customers by Sept 1.
Email subject: [Approval required] Billing Migration — Decision Needed by Aug 12
Email body: Please review the one-pager and confirm approvals for legal, finance, and pilot customers.Prompt 5: OKR-to-Feature Mapping
Full prompt text (copy-paste)
You are an OKR analyst. Map the following OKRs to a set of features and measurable success criteria. For each OKR, list 3–7 candidate features, prioritized by expected contribution to the objective, with a confidence score (0–100) and recommended metric (with baseline and target). Input: OKRs: {OKR_LIST}. Output: JSON with `okr_mappings` each containing okr_id, summary, features (name, description, contribution_rank, confidence, metric, baseline, target), and a 'quick_recommendation' field with the top 2 features to commit to this quarter.When to use it
Use when translating strategic OKRs into a tactical backlog for the quarter. This is useful for aligning engineering capacity to measurable objectives.
Expected output format
JSON object with okr_mappings array; each mapping includes features array and a quick_recommendation string.
Pro tips for customization
- When OKRs span multiple teams, include “owner_team” and “cross_team_dependencies” properties for each feature.
- Ask for a “confidence breakdown” that explains what data or experiments would raise the confidence score.
- For revenue-linked OKRs, request a mini financial model with assumptions for conversion and average revenue per user (ARPU).
Example output snippet
{
"okr_mappings": [
{
"okr_id": "OKR-1",
"summary": "Increase self-serve ARR by 30% in FY27",
"features": [
{"name":"Usage Billing", "description":"Meter usage and bill monthly", "contribution_rank":1, "confidence":70, "metric":"ARR expansion rate", "baseline":"10%/Q", "target":"18%/Q"}
],
"quick_recommendation":"Commit to Usage Billing and Self-Serve Onboarding this quarter"
}
]
}
Section 2 — User Story Writing (5 prompts)
Prompt 6: Epic Decomposition into User Stories
Full prompt text (copy-paste)
You are an experienced agile writer. Decompose the following epic into a set of user stories suitable for a 3-month roadmap. For each story, provide: title, user role, goal, acceptance criteria (GIVEN-WHEN-THEN format), dependencies, estimated story points (Fibonacci scale), and required QA test cases. Epic: {EPIC_DESCRIPTION}. Constraints: {CONSTRAINTS}.When to use it
Use this prompt when a large initiative needs to be broken down into actionable, estimable backlog items for sprint planning and sprint commits.
Expected output format
JSON array named “stories” or markdown-ready story cards. Each item includes fields: title, role_goal, acceptance_criteria, dependencies, story_points, qa_tests.
Pro tips for customization
- Provide persona names and journeys to make stories human-centered and measurable.
- Ask the model to mark stories as MVP vs Post-MVP to guide release scope.
- For engineering-heavy stories, add “tech_notes” to indicate non-functional requirements (scalability, security, latency).
Example output snippet
{
"stories": [
{
"title":"User can sign up with SSO",
"role_goal":"As an enterprise admin, I want to sign up via SSO so I avoid shared passwords",
"acceptance_criteria": [
"GIVEN: New enterprise user on signup page",
"WHEN: User selects SSO and completes provider auth",
"THEN: Account is created and user is redirected to onboarding"
],
"dependencies":["Identity provider integration", "Provisioning API"],
"story_points":8,
"qa_tests":["SSO success flow", "SSO failure flow", "Mismatch email domain"]
}
]
}Prompt 7: Acceptance Criteria Generation & Edge Case Detection
Full prompt text (copy-paste)
Analyze the following user story and produce exhaustive acceptance criteria and a prioritized list of edge cases (High/Medium/Low risk). For each acceptance criterion include test steps and expected results. User story: {USER_STORY}. System constraints: {CONSTRAINTS}. Output: JSON with `acceptance_criteria` (array) and `edge_cases` (array with severity, rationale, repro steps, and suggested mitigation).When to use it
Use this prompt during story refinement or QA planning. It substantially reduces back-and-forth between product, QA, and engineering by specifying testable conditions and exposing edge cases early.
Expected output format
JSON with arrays; acceptance criteria entries should include id, description, test_steps (ordered), expected_result. Edge cases include severity, scenario, repro_steps, probability estimate, and mitigation.
Pro tips for customization
- Include system-level constraints such as rate limits, storage caps, and privacy rules to detect important edge cases.
- Request “negative test” cases explicitly (auth failures, quota exceeded, malformed input).
- If you track SLAs, ask the model to add latency targets and monitoring alerts as acceptance criteria.
Example output snippet
{
"acceptance_criteria":[
{"id":"AC-1","description":"Successful creation of resource","test_steps":["Step 1: POST /resources","Step 2: Verify 201 response"], "expected_result":"201 created with resource id"}
],
"edge_cases":[
{"severity":"High","scenario":"Duplicate request within 1s","repro_steps":["Send same POST twice quickly"],"probability":"Medium","mitigation":"Idempotency token"}
]
}Prompt 8: Story Point Estimation Guide with Team Calibration
Full prompt text (copy-paste)
Act as an agile estimation facilitator. Given these stories and our team's baseline velocity and composition, produce story point estimates (Fibonacci) and justification for each estimate. Also produce calibration guidance for a 60-minute estimation meeting with suggested Fist-of-Five anchor stories. Input: team_profile: {TEAM_PROFILE}, velocity: {AVG_VELOCITY}, stories: {STORY_LIST}. Output: JSON with story estimates and a meeting agenda (roles, timebox, anchor stories, sample questions).When to use it
Use this prior to or during sprint planning to save time and provide defensible starting estimates that the team can adjust during live estimation ceremonies.
Expected output format
JSON with “estimates” array and “meeting_agenda” object listing anchor stories and timeboxes. Each estimate should include rationale referencing complexity, unknowns, and integration effort.
Pro tips for customization
- Provide one or two anchor stories (e.g., small = 2, medium = 5, large = 13) so the model calibrates to your team’s scale.
- If your team uses T-shirt sizes, ask for a dual representation (points + T-shirt).
- Have the model return “risks” that might increase point values after discovery work.
Example output snippet
{
"estimates":[
{"title":"SSO Signup","points":8,"rationale":"OAuth flows + vendor config + email mapping"},
{"title":"Refactor Billing Service","points":13,"rationale":"DB migration + schema changes"}
],
"meeting_agenda":{
"total_time":"60m",
"anchor_stories":["Bugfix minor (2)", "New major flow (13)"],
"timeboxes":"5m per story"
}
}Prompt 9: Technical Specification from User Stories
Full prompt text (copy-paste)
You are a technical product writer. Convert the following set of user stories into a technical specification for the engineering team. Include: API contract (endpoints, request/response), data model changes, DB migration plan, non-functional requirements (scaling, latency, security), integration test matrix, rollout plan with feature flags, and monitoring/alerting needs. Stories: {STORIES}. Output: JSON with `api_contract`, `data_model`, `migration_plan`, `nfrs`, `tests`, `rollout_plan`, and a human-readable section to paste into an RFC or PRD.When to use it
Use this prompt to convert product-level stories into developer-ready specs, or to create a first draft of an RFC which developers can iterate on.
Expected output format
JSON object with keys for each engineering deliverable plus an RFC-ready markdown document.
Pro tips for customization
- Provide schema examples or existing API contracts to maintain consistency with your platform design patterns.
- For regulated domains, add compliance requirements (e.g., SOC2 controls, encryption-at-rest) to the NFRs section.
- Ask the model to produce migration rollback steps and a data validation checklist for post-migration verification.
Example output snippet
{
"api_contract":{
"POST /v2/resources": {"request":{"name":"string","owner_id":"uuid"},"response":{"id":"uuid","created_at":"iso"}}
},
"data_model":{"Resource":{"id":"uuid","name":"string","owner_id":"uuid"}},
"migration_plan":["Add new table resources_v2","Backfill from resources_v1","Cutover in maintenance window"]
}Prompt 10: Acceptance to Implementation Handoff Template
Full prompt text (copy-paste)
Create a handoff document template for the engineering team from acceptance criteria to implementation. The template should include fields for: acceptance criteria, API contracts, UI mocks with annotations, data contracts, migration notes, test cases, performance budgets, monitoring metrics, and a checklist for "ready to merge". Output the template in JSON and in a Confluence-friendly markdown format that PMs can fill during grooming.When to use it
Use this prompt to standardize handoffs and reduce implementation ambiguity between PMs and engineers. This is especially valuable in distributed or cross-functional teams.
Expected output format
JSON template with required keys and a markdown version for immediate use in Confluence/Notion.
Pro tips for customization
- Customize the “performance budgets” and “monitoring metrics” to reflect your SLOs and business KPIs.
- Include a “rollback decision matrix” for high-risk migrations (who approves, what metrics to monitor).
- Add a “security review status” field to surface pending security tasks before merge.
Example output snippet
{
"handoff_template":{
"accepted_criteria":["AC-1","AC-2"],
"api_contract":"{POST /v2/resource ...}",
"ui_mocks":"link_to_design",
"test_cases":["success_flow","error_flow"]
},
"confluence_markdown":"## Implementation Handoff\n- Acceptance Criteria: ...\n- API Contract: ..."
}Section 3 — Competitive Analysis (5 prompts)
Prompt 11: Feature Comparison Matrix for Competitors
Full prompt text (copy-paste)
You're a competitive analyst. Create a feature comparison matrix for the product and its main competitors. Input includes a list of competitors with public specs and a prioritized feature list: {COMPETITOR_LIST}, {FEATURES}. For each product and each feature, indicate: presence (Yes/No), maturity level (Basic/Advanced/Enterprise), and supporting evidence (link or quote). Output a CSV-ready table and a JSON object `comparison` with fields product, feature, presence, maturity, evidence, estimated_usability_score (1-10). Also provide a short strategic recommendation (3 bullets) based on identified gaps.When to use it
Use this prompt when preparing competitive audits, sales enablement docs, or when planning product differentiation strategies.
Expected output format
CSV table and JSON with comparison objects; a concluding recommendations section in plain text.
Pro tips for customization
- For more defensible claims, pass in curated competitor excerpts or URLs. The model can summarize them into evidence fields.
- When usability matters, add a request for UX heuristics (e.g., onboarding steps, time-to-first-success).
- Ask the model to tag features that are core differentiators vs. commoditized.
Example output snippet (CSV)
product,feature,presence,maturity,evidence,usability_score
OurProduct,SSO,Yes,Advanced,"docs.example.com/sso",8
CompetitorA,SSO,Yes,Basic,"competitor/docs",5
CompetitorB,SSO,No,,,""Comparison table: Feature presence heatmap (example)
| Feature | Our Product | Competitor A | Competitor B |
|---|---|---|---|
| SSO | Advanced | Basic | No |
| Usage Billing | Advanced | Basic | Advanced |
| Embedded Analytics | Basic | Advanced | Basic |
Prompt 12: Market Positioning and Narrative Map
Full prompt text (copy-paste)
Produce a market positioning map and narrative for {PRODUCT_NAME} targeted at {SEGMENT}. Use the following axes for the positioning map: X = Price/Cost (Low → High), Y = Feature Depth (Narrow → Deep). Place each competitor in the map with justification. Then craft three positioning statements targeted to: (1) enterprise buyers, (2) SMB/self-serve, (3) engineering buyers. Provide recommended messaging pillars and a 30-word elevator pitch for each persona.When to use it
Use for GTM alignment, messaging workshops, and to inform sales battlecards. This prompt helps convert product differentiation into persona-specific messages.
Expected output format
JSON containing map coordinates and positioning statements, plus a markdown section with suggested messaging pillars and elevator pitches.
Pro tips for customization
- Define the actual coordinates or ask the model to infer coordinates using competitor pricing and feature counts.
- For enterprise messaging, ask the model to include procurement and security hooks (e.g., SOC2, data residency).
- Use the elevator pitches directly for pitch decks or SDR scripts; ask for A/B variants (formal vs conversational).
Example output snippet
{
"map": {
"OurProduct": {"x":7,"y":8,"justification":"High feature depth + mid-high price"},
"CompetitorA": {"x":4,"y":6,"justification":"Lower price, fewer enterprise features"}
},
"positioning_statements":{
"enterprise":"For enterprise IT teams, OurProduct provides deep integration and governance controls enabling secure self-service at scale."
}
}Prompt 13: Pricing Strategy Evaluation
Full prompt text (copy-paste)
Assess a pricing strategy for FY27. Input includes: current pricing tiers and metrics (MAU, seats, usage), competitor pricing, cost structure per customer, target ARR growth, and churn targets. Provide: a) a comparative pricing analysis, b) 3 alternative pricing strategies (e.g., usage-based, seat-based + overage, enterprise custom) with modeled P&L impact over 12 months (assumptions noted), c) recommended rollout (pilot customers, A/B test plan, telemetry to monitor), and d) risks and mitigation plans. Output: well-structured JSON and a one-page summary suitable for finance and GTM review.When to use it
Use this prompt when evaluating a pricing change, planning a test, or when you need a finance-informed view of pricing options quickly.
Expected output format
JSON with `analysis`, `strategies` (each with modeled ARR and churn impact assumptions), `rollout_plan`, `metrics_to_track` (LTV, CAC payback, churn), and a short one-page summary in markdown.
Pro tips for customization
- Provide exact cost per customer and current ARPU for more accurate P&L modeling.
- Ask for sensitivity analysis across 3 adoption scenarios (pessimistic, expected, optimistic).
- When proposing usage-based plans, specify minimum commitment levels and billing cadence.
Example output snippet
{
"strategies":[
{"name":"Usage-based meter", "assumptions":{"adoption":0.15,"avg_usage_per_customer":1000},"modeled_12m_ARR":1200000}
],
"metrics_to_track":["ARPU","Gross churn","MRR Expansion"]
}Prompt 14: SWOT Generation for Product Line
Full prompt text (copy-paste)
Generate a comprehensive SWOT (Strengths, Weaknesses, Opportunities, Threats) for {PRODUCT_NAME} in the {MARKET} as of July 2026. For each item, include evidence/data points (internal metrics or public market signals), recommended tactical actions (owner, timeline), and a confidence score (0–100). Output as JSON with arrays for strengths, weaknesses, opportunities, threats, and a short executive summary of recommended strategic moves.When to use it
Use in quarterly business reviews, investor updates, or strategy workshops to ground decisions in structured analysis and action items.
Expected output format
JSON with arrays; each item includes text, evidence, recommended_action (owner, due_date), and confidence.
Access 40,000+ AI Prompts for ChatGPT, Claude & Codex — Free!
Subscribe to get instant access to our complete Notion Prompt Library — the largest curated collection of prompts for ChatGPT, Claude, OpenAI Codex, and other leading AI models. Optimized for real-world workflows across coding, research, content creation, and business.
Pro tips for customization
- Seed the prompt with your top 3 internal metrics (e.g., NPS, churn, ARR growth) to anchor the analysis.
- For competitive threats, include recent public announcements or funding rounds to increase signal fidelity.
- Prioritize opportunities by expected revenue or strategic importance and request a quick scoring rubric for prioritization.
Example output snippet
{
"strengths":[
{"text":"High onboarding conversion","evidence":"Activation up 15% YoY","recommended_action":{"owner":"Growth PM","timeline":"Q3"}, "confidence":85}
],
"weaknesses":[{"text":"No advanced analytics", "evidence":"Feature gap vs Competitor B", "confidence":70}]
}Prompt 15: Competitive Moat Assessment & Durability Analysis
Full prompt text (copy-paste)
Evaluate the durability of {PRODUCT_NAME}'s competitive moats across three dimensions: technology, go-to-market, and data/network effects. For each dimension provide: current moat strength (0–10), pillars supporting the moat, potential erosion vectors, time-to-erosion estimate (months), and 3 recommended investments to strengthen the moat (with rough cost estimate and expected payoff). Output: JSON `moat_assessment` and a 200-word executive summary suitable for leadership.When to use it
Use this prompt when assessing long-term defensibility for fundraising, M&A diligence, or strategic planning.
Expected output format
JSON with moat_assessment keyed by dimension and a plain-text summary. Each entry includes numeric strength, pillars, erosion_vectors, time_to_erosion, investments (cost_estimate, expected_payoff).
Pro tips for customization
- Provide specifics of technology stack, partner agreements, or proprietary datasets to get more accurate moat estimates.
- Ask for a prioritized investment plan with ROI timelines aligned to your fiscal planning horizon.
- For deeper diligence, request a red-team view: how a well-funded entrant could attack your moat within 12 months.
Example output snippet
{
"moat_assessment":{
"technology":{"strength":7,"pillars":["proprietary query engine"],"erosion_vectors":["open-source improvements"],"time_to_erosion_months":24,"investments":[{"name":"Hardening engine","cost_kusd":250,"expected_payoff":"Reduce cost by 15%"}]}
},
"executive_summary":"OurProduct has a defensible technology moat but needs investments in..."
}
Section 4 — Sprint Retrospectives (5 prompts)
Prompt 16: Retro Facilitation Script and Agenda
Full prompt text (copy-paste)
You are a senior agile coach. Create a 45-minute retrospective facilitation script for a cross-functional team, including timeboxed activities: check-in, data review, insight generation, decision-making, action selection, and check-out. Include: prompts for the facilitator, templates for team input (e.g., Start/Stop/Continue), voting mechanism, a decision matrix for selecting top actions, and an optional async template for remote teams. Input: team_size={TEAM_SIZE}, primary_focus={FOCUS}. Output: JSON `agenda`, facilitator_script (step-by-step), and an async_template (markdown).When to use it
Use before or during retros to ensure a productive, timeboxed meeting with clear outputs and owner assignments. The async template supports distributed teams or those in multiple time zones.
Expected output format
JSON carrying agenda items and facilitator script lines; markdown async template for copy-paste into Slack/Notion.
Pro tips for customization
- Adjust timeboxes depending on team size, e.g., 60–75 minutes for teams >10.
- Add quantitative prompts when you have velocity and incident KPIs to ground the discussion.
- Use the decision matrix to prioritize action items by expected impact vs implementation effort and embed owner/time targets directly in the output.
Example output snippet
{
"agenda":[{"time":"5m","activity":"Check-in"},{"time":"10m","activity":"Data review: Velocity, Incidents, PR cycle time"}],
"facilitator_script":"Welcome -> 5m check-in prompt: 'What's one win and one pain from the sprint?'"
}Prompt 17: Action Item Extraction from Retro Notes
Full prompt text (copy-paste)
Given the following raw retro notes or transcript, extract action items with owner, due date suggestion (two-week sprint default), priority (High/Medium/Low), and acceptance criteria for each action. Also detect recurring themes across multiple retros (if provided). Input: {RETRO_NOTES_OR_TRANSCRIPT}. Output: JSON array `actions` plus `recurring_themes` and `follow_up_template` for the next retro.When to use it
Use this prompt to quickly parse meeting notes into operational tasks that can be assigned in Jira or your task tracker.
Expected output format
JSON array of actions, each with title, description, owner_hint, suggested_due_date, priority, acceptance_criteria; and a recurring_themes array listing theme and frequency.
Pro tips for customization
- Include role hints for owners (e.g., “backend lead”, “QA”) so the model can suggest realistic owners when names are absent.
- When transcript timestamps exist, ask the model to include time offsets to allow quick verification.
- For regulatory work, add a compliance tag to actions that affect audit trails.
Example output snippet
{
"actions":[
{"title":"Automate smoke tests","description":"Create nightly smoke tests for main flows","owner_hint":"QA lead","due_in_days":10,"priority":"High","acceptance_criteria":"Nightly job succeeds for critical paths for 5 days"}
],
"recurring_themes":[{"theme":"CI flakiness","frequency":3}]
}Prompt 18: Velocity and Trend Analysis
Full prompt text (copy-paste)
Analyze the following sprint velocity data and provide insights, forecast next 3 sprints' velocity range, detect anomalies, and recommend adjustments for planning. Input: sprint_data: [{sprint_id, start_date, end_date, committed_points, completed_points, team_size, blocked_days}...]. Output: JSON with `insights` (top 5), `forecast` (median & 95% CI), `anomalies` (with rationale), `planning_recommendation` (suggested committed points for next 3 sprints).When to use it
Use for capacity planning, release forecasting, and to set realistic sprint commitments based on historical data and current constraints.
Expected output format
JSON with insights and a forecast object containing per-sprint recommended commit and confidence intervals. Include a short textual justification for any downward adjustments.
Pro tips for customization
- Include known upcoming events (holidays, planned vacations) so forecasts reflect capacity changes.
- Request both median and mean forecasts; medians are more robust to outliers on velocity.
- Ask for a visualization-ready CSV to paste into BI tools for charting.
Example output snippet
{
"insights":["Commits exceeded completed by 20% over last 4 sprints; CI regressions correlated with lower velocity"],
"forecast":[{"sprint":"Sprint 42","recommended_commit":24,"95_ci":[18,30]}]
}Prompt 19: Team Sentiment Analysis from Retro Comments
Full prompt text (copy-paste)
Perform sentiment analysis on an array of retro comments or chat logs. For each comment provide: sentiment (Positive/Neutral/Negative), emotion tags (frustration, pride, confusion, tired), an inferred root cause if negative, and a suggested micro-action to address it (owner, time-frame). Also produce a team-level sentiment score (0–100) and a short guidance section for managers. Input: comments: [{author, text, timestamp}]. Output: JSON `comment_analysis`, `team_sentiment_score`, and `manager_guidance`.When to use it
Use this to surface hidden morale issues or to quantify team health across sprints, enabling managers to take targeted actions quickly.
Expected output format
JSON arrays for comment_analysis with sentiment/emotion/root_cause/action and a top-level numeric team_sentiment_score plus manager_guidance.
Pro tips for customization
- When analyzing cross-cultural teams, ask the model to avoid strong cultural bias in emotion tagging and to provide neutral phrasing for manager actions.
- For privacy, anonymize comments or restrict output to aggregated signals only.
- Request an action priority matrix that maps urgency vs potential impact for each micro-action.
Example output snippet
{
"comment_analysis":[
{"author":"anon","sentiment":"Negative","emotion":["frustration"],"root_cause":"Blocked by external API rate limits","suggested_action":{"owner":"Platform lead","by":"3 days"}}
],
"team_sentiment_score":64,
"manager_guidance":"Address API blocking points immediately; celebrate small wins in next standup."
}Prompt 20: Improvement Hypothesis Generation & A/B Test Design
Full prompt text (copy-paste)
Generate 5 high-confidence improvement hypotheses based on the last sprint's metrics: {METRICS} (examples: activation, retention, error rates). For each hypothesis provide: hypothesis statement, estimated impact on metric (with rationale), required experiment design including variants, sample size calc (stat test and assumptions), primary metric, guardrail metrics, rollout plan, and decision thresholds (statistical significance and minimum detectable effect). Output JSON with `hypotheses` and a short experimental priority ranking.When to use it
Use after retrospectives when the team wants to turn learnings into measurable experiments with clear success criteria and rollout plans.
Expected output format
JSON array of hypotheses with experiment design fields and a prioritized list by expected ROI and lowest implementation cost.
Pro tips for customization
- Supply realistic baseline conversion rates and traffic volumes for accurate sample size calculations.
- If you do sequential testing or Bayesian analysis, specify the statistical framework you prefer.
- For high-risk experiments, include a safety stop condition if guardrail metrics cross threshold during rollout.
Example output snippet
{
"hypotheses":[
{"statement":"Adding contextual tips during onboarding increases activation from 24% to 32%","estimated_impact":"+8pp","experiment":{"variants":["control","with_tips"],"sample_size":4800,"primary_metric":"7-day activation","guardrails":["error_rate","support_tickets"]},"decision_threshold":"p<0.05 and uplift>=5pp"}
],
"priority_ranking":["Onboarding tips","SSO improvement","Performance optimization"]
}Practical Integrations and Automation
Below are practical examples showing how to automate prompt execution and parse model results. These snippets assume your enterprise instance of ChatGPT-5.5 accepts JSON-formatted prompts and returns JSON responses. Replace placeholders with your data and secrets and follow your company’s security policies.
Example: Python wrapper to run a prompt and store JSON
import requests, json
API_URL="https://api.enterprise-openai.example/v1/chat"
API_KEY="REPLACE_WITH_SECURE_SECRET"
def run_prompt(prompt_text, system="You are a helpful PM assistant"):
payload={
"model":"chatgpt-5.5",
"messages":[
{"role":"system","content":system},
{"role":"user","content":prompt_text}
],
"max_tokens":2000,
"temperature":0.2
}
headers={"Authorization":f"Bearer {API_KEY}","Content-Type":"application/json"}
r=requests.post(API_URL,json=payload,headers=headers,timeout=60)
return r.json()
prompt = "Paste one of the full prompt texts here with concrete context..."
result = run_prompt(prompt)
print(json.dumps(result,indent=2))Example: JSON schema for ingestion into a planning tool
{
"initiativeId":"string",
"name":"string",
"description":"string",
"owner":"string",
"estimate":"S|M|L",
"targetMetric":{"name":"string","baseline":0,"target":0},
"dependencies":["initiativeIdA","componentIdB"],
"rolloutPlan":[{"week":1,"tasks":["..."]}],
"successCriteria":["..."]
}Additional Comparison Tables
| Prioritization Use Case | Recommended Framework | Why |
|---|---|---|
| Consumer feature prioritization | RICE | Quantifies reach and is data-friendly |
| Quick product decisions | ICE | Fast and simple |
| Program-level sequencing | WSJF | Accounts for cost of delay |
| Scoping releases | MoSCoW | Stakeholder-aligned and qualitative |
| Use-case | Tooling Output | Import Target |
|---|---|---|
| Quarterly roadmap | JSON + Markdown | Jira/Confluence/Notion |
| User stories | JSON cards with ACs | Jira/Trello |
| Competitive matrix | CSV/JSON | Sales enablement portal |
FAQ
Q: How should I secure sensitive product data when using ChatGPT-5.5 prompts?
Do not include highly sensitive data (customer PII, secrets, unreleased financials) in prompts unless your organization’s model instance and data handling policies explicitly permit it. Use abstractions (e.g., “baseline DAU = 50k” rather than detailed customer lists). If you operate an on-prem or enterprise instance with approved data contracts, follow your security team’s encryption, logging, and access control guidelines. Mask or hash identifiers where possible.
Q: How accurate are impact estimates the model provides for roadmap items?
Estimates from ChatGPT-5.5 are only as accurate as the inputs and assumptions provided. Use the model’s outputs as structured hypotheses, not definitive forecasts. For higher fidelity, supply real quantitative baselines (metrics, historical conversion rates), ask the model to produce confidence intervals, or run suggested experiments to validate assumptions before allocating significant resources.
Q: Can I automate these prompts to run nightly and update dashboards?
Yes. Use your enterprise API to automate prompt execution, save JSON outputs to your data warehouse, and create ETL pipelines to update dashboards or planning tools. Respect rate limits and privacy policies. For change detection (e.g., detect significant drift in competitor features), implement alerting when model outputs change materially from prior runs.
Q: How do I prevent model hallucinations in competitive analysis or evidence fields?
To reduce hallucinations, pass in authoritative sources (links, scraped specs, public docs) as context and instruct the model to cite sources or mark statements as “inferred” vs “sourced”. When high confidence is required, validate model claims against primary sources or use human-in-the-loop verification before publishing external-facing materials.
Q: What is the recommended way to manage follow-ups and versioning of the generated artifacts?
Adopt a provenance and versioning strategy: store prompt text, model version (e.g., ChatGPT-5.5), context inputs, and resulting JSON in a change-control system or database. Tag major revisions with semantic version numbers and maintain audit logs for stakeholder reviews and decision points. Integrate results into your PRD or RFC repository so changes can be reviewed in code-style diffs.
Q: Can the model estimate sample sizes and statistical power for experiments?
Yes — the model can compute sample sizes using common formulas (z-test, t-test, or approximate binomial calculations) if given baseline rates, desired minimum detectable effect, significance level (alpha), and power. For mission-critical experiments, consult a statistician or analytic team to validate assumptions and methods, especially when running sequential or adaptive tests.
Q: How do you recommend handling cultural or geographic differences in stakeholder language when generating alignment documents?
Specify audience context (region, cultural norms, preferred tone) in the prompt. Request localized language variations and concise executive summaries for multicultural stakeholders. When negotiating legal or regulatory topics, attach region-specific compliance references and ask the model to use neutral, explicit language that avoids idioms potentially misunderstood by non-native speakers.
Closing Notes — Best Practices for Product Managers (July 2026)
ChatGPT-5.5 is a force-multiplier for product teams: it accelerates drafting, reduces ceremony, and codifies tribal knowledge into repeatable artifacts. The prompts in this playbook are intentionally prescriptive — copy-paste to start, then iterate. The highest-leverage pattern is to pair model outputs with short experiments: validate assumptions with quantitative signals, then lock in decisions. Maintain human oversight for strategic decisions, and treat the model as a sophisticated, fast collaborator that can produce structured drafts, not as a final approver.
Finally, continuously refine your prompt templates. Track prompt-to-outcome correlations (which prompt variants produced the most accurate estimates or best stakeholder buy-in) and version-control your prompt library. With a disciplined approach, these 20 prompts will help you standardize planning, accelerate execution, and create alignment across product, engineering, and GTM functions.
