A Product Requirement Document (PRD) is a foundational artifact in product management that outlines the purpose, scope, and specifications of a product feature or release. It serves as a single source of truth for cross-functional teams including engineering, design, marketing, and QA. A well-structured PRD ensures alignment, reduces ambiguity, and accelerates delivery.

Key sections typically include:

• Overview: High-level summary and context.
• Goals: Clear, measurable objectives.
• User Personas: Target users and their characteristics.
• User Needs: Problems or desires the feature addresses.
• Functional Requirements: Specific behaviors and capabilities.
• Non-Functional Requirements: Performance, security, usability constraints.
• Dependencies: Internal and external systems involved.
• Success Metrics: KPIs to evaluate feature impact.

Using GPT-5.5 to generate a PRD outline based on a feature description can save time and ensure completeness.

1. Prepare a clear feature description: Summarize the feature’s purpose, target users, and expected benefits in 2-3 sentences.
2. Input the description into the prompt: Replace <Insert feature description here> with your prepared text.
3. Run the prompt in GPT-5.5: Request the output as a structured markdown document.
4. Review and customize: Edit the generated PRD outline to fit your organization’s standards and add any missing details.
5. Share with stakeholders: Use the PRD as a collaboration tool for feedback and alignment.

This approach accelerates PRD creation while maintaining thoroughness.

Using the following feature description, create a detailed Product Requirement Document (PRD) outline including sections for Overview, Goals, User Personas, User Needs, Functional Requirements, Non-Functional Requirements, Dependencies, and Success Metrics.

Feature Description: <Insert feature description here>

Please format the output as a structured markdown document with headings and bullet points.

# Product Requirement Document (PRD) - <Feature Name>

## 1. Overview
- Brief summary of the feature

## 2. Goals
- List of measurable objectives

## 3. User Personas
- Persona 1: Description
- Persona 2: Description

## 4. User Needs
- Need 1
- Need 2

## 5. Functional Requirements
- Requirement 1
- Requirement 2

## 6. Non-Functional Requirements
- Performance
- Security

## 7. Dependencies
- Internal systems
- External APIs

## 8. Success Metrics
- Metric 1
- Metric 2
      

At a leading SaaS company, product managers used this GPT-5.5 prompt to rapidly generate PRD outlines for quarterly feature releases. This practice reduced initial drafting time by 40%, enabling earlier stakeholder reviews and quicker iteration cycles.

The RICE scoring model is a quantitative prioritization framework that helps product teams objectively rank features based on four dimensions:

• Reach: How many users will be affected within a time frame.
• Impact: The degree of benefit to users (often scored 1-3 or 1-5).
• Confidence: How sure you are about your estimates (percentage).
• Effort: Estimated person-months or points required to build.

The formula is: RICE Score = (Reach × Impact × Confidence) / Effort. Higher scores indicate higher priority.

Using GPT-5.5 to calculate and sort features by RICE score can streamline backlog grooming and roadmap planning.

1. Compile feature data: For each feature, estimate Reach, Impact, Confidence, and Effort.
2. Format the list as per the prompt: Replace placeholders with actual values.
3. Run the prompt: GPT-5.5 will calculate RICE scores and output a prioritized table.
4. Validate results: Cross-check scores with team insights and adjust estimates if necessary.
5. Use the prioritized list: Inform sprint planning, resource allocation, and stakeholder communication.

Given the following list of features with their Reach, Impact, Confidence, and Effort scores, calculate the RICE score for each feature and provide a prioritized list sorted from highest to lowest score.

Features:
1. <Feature A> - Reach: <number>, Impact: <number>, Confidence: <percentage>, Effort: <number>
2. <Feature B> - Reach: <number>, Impact: <number>, Confidence: <percentage>, Effort: <number>
...

Please output a table with columns: Feature, Reach, Impact, Confidence, Effort, RICE Score, Priority Rank.

| Feature   | Reach | Impact | Confidence | Effort | RICE Score | Priority Rank |
|-----------|-------|--------|------------|--------|------------|---------------|
| Feature A | 1000  | 3      | 80%        | 5      | 480        | 1             |
| Feature B | 800   | 4      | 90%        | 8      | 360        | 2             |
| ...       | ...   | ...    | ...        | ...    | ...        | ...           |
      

<!-- 
This Python script demonstrates how to calculate RICE scores for a list of features and output a sorted table.
-->
<script type="text/python">
import pandas as pd

# Sample feature data
features = [
    {"Feature": "Feature A", "Reach": 1000, "Impact": 3, "Confidence": 0.8, "Effort": 5},
    {"Feature": "Feature B", "Reach": 800, "Impact": 4, "Confidence": 0.9, "Effort": 8},
    {"Feature": "Feature C", "Reach": 1500, "Impact": 2, "Confidence": 0.7, "Effort": 6},
]

# Calculate RICE score
for feature in features:
    feature["RICE Score"] = (feature["Reach"] * feature["Impact"] * feature["Confidence"]) / feature["Effort"]

# Create DataFrame
df = pd.DataFrame(features)

# Sort by RICE Score descending
df = df.sort_values(by="RICE Score", ascending=False).reset_index(drop=True)

# Add Priority Rank
df["Priority Rank"] = df.index + 1

print(df[["Feature", "Reach", "Impact", "Confidence", "Effort", "RICE Score", "Priority Rank"]])
</script>
      

A fintech startup used the RICE framework with GPT-5.5 assistance to prioritize features for their mobile app. By quantifying assumptions and automating calculations, they improved roadmap transparency and stakeholder buy-in, resulting in a 25% faster time-to-market.

Competitive analysis is a critical strategic activity that helps product teams understand the market landscape, identify gaps, and uncover opportunities. A focused competitive analysis on a specific feature allows teams to benchmark against rivals, evaluate strengths and weaknesses, and make informed product decisions.

Key dimensions to analyze include:

• Feature Availability: Does the competitor offer this feature fully, partially, or not at all?
• Strengths: What advantages or unique aspects does the competitor’s implementation have?
• Weaknesses: Limitations, usability issues, or missing elements.
• Pricing: Cost structure related to the feature.
• User Feedback: Customer sentiment and reviews highlighting experience.

GPT-5.5 can synthesize large volumes of competitive data into concise, structured reports, saving hours of manual research.

1. Identify competitors: Select at least three direct or indirect competitors relevant to your feature.
2. Gather data: Collect information on feature availability, pricing, user reviews, and known strengths/weaknesses.
3. Input data into the prompt: Replace placeholders with competitor names and feature details.
4. Run the prompt: GPT-5.5 will generate a structured report with tables and bullet points.
5. Analyze output: Use the report to identify opportunities for differentiation and potential threats.

Analyze the competitive landscape for the following feature: <Feature Name>. Compare at least three competitors on feature availability, strengths, weaknesses, pricing, and user feedback. Provide a concise summary highlighting opportunities and threats.

Competitors:
- <Competitor 1>
- <Competitor 2>
- <Competitor 3>

Format the output as a structured report with bullet points and tables where appropriate.

# Competitive Analysis - <Feature Name>

| Competitor   | Feature Availability | Strengths              | Weaknesses           | Pricing     | User Feedback Summary    |
|--------------|---------------------|-----------------------|----------------------|-------------|--------------------------|
| Competitor 1 | Yes                 | Fast, reliable        | Limited integrations | $29/month   | Mostly positive, some UX issues |
| Competitor 2 | Partial             | Extensive features    | Complex UI           | $49/month   | Mixed reviews             |
| Competitor 3 | No                  | N/A                   | N/A                  | N/A         | N/A                      |

## Opportunities
- Opportunity 1
- Opportunity 2

## Threats
- Threat 1
- Threat 2
      

<!-- 
This Python script uses pandas to create a competitive analysis table and outputs a markdown report.
-->
<script type="text/python">
import pandas as pd

# Define competitor data
data = {
    "Competitor": ["Competitor 1", "Competitor 2", "Competitor 3"],
    "Feature Availability": ["Yes", "Partial", "No"],
    "Strengths": ["Fast, reliable", "Extensive features", "N/A"],
    "Weaknesses": ["Limited integrations", "Complex UI", "N/A"],
    "Pricing": ["$29/month", "$49/month", "N/A"],
    "User Feedback Summary": [
        "Mostly positive, some UX issues",
        "Mixed reviews",
        "N/A"
    ]
}

df = pd.DataFrame(data)

# Output markdown table
print("# Competitive Analysis - <Feature Name>\n")
print(df.to_markdown(index=False))

print("\n## Opportunities\n- Opportunity 1\n- Opportunity 2\n")
print("## Threats\n- Threat 1\n- Threat 2\n")
</script>