Ready-to-use AI prompts for Product Managers who need user stories, acceptance criteria, and backlog documentation finished fast. Copy, paste variables, and get production-ready agile artifacts in seconds.
These prompts pair well with Jasper AI for Product Managers-specific tone control, or Copy.ai for fast iteration.
Epic Breakdown and User Story Creation
You are a Product Manager breaking down a large epic into actionable user stories for sprint planning.
Epic: {epic_title} Product: {product_name} User persona: {primary_user_type} Business goal: {business_objective} Technical constraints: {tech_limitations} Sprint capacity: {story_points_available} Priority focus: {must_have_vs_nice_to_have}
Write 5-8 user stories using the format “As a [user], I want [goal] so that [benefit]”. Each story should be 1-2 sentences maximum. Include story point estimates (1, 2, 3, 5, 8). Order by priority with highest impact stories first. End each story with one acceptance criteria written as “Given/When/Then”.
When to use it: Monday morning sprint planning when you have a large feature that needs to be broken down into manageable chunks for the team.
Pro tip: Set {story_points_available} to 80% of your actual capacity. This prevents the AI from creating an overly ambitious sprint that your team can’t deliver.
You are a Product Manager writing user stories for a mobile app feature that needs accessibility compliance.
Feature: {feature_name} App platform: {ios_android_both} Target users: {user_demographic} Accessibility requirements: {wcag_level_or_specific_needs} Current user pain point: {problem_being_solved} Success metric: {measurable_outcome} Development timeline: {weeks_available}
Create 3-4 user stories that include accessibility considerations. Use the format “As a [user type], I want [functionality] so that [value]”. Include one story specifically for users with {accessibility_requirements}. Keep each story under 25 words. Add acceptance criteria focusing on both functionality and accessibility testing.
When to use it: When building features that must meet accessibility standards or serve users with specific needs.
Pro tip: Always include one dedicated accessibility story rather than adding accessibility as an afterthought to functional stories. It gets proper attention and testing time.
You are a Product Manager converting customer feedback into actionable user stories for the next sprint.
Customer feedback summary: {feedback_themes} Product area affected: {feature_or_module} Customer segment: {enterprise_smb_consumer} Frequency of request: {how_often_mentioned} Revenue impact: {potential_business_value} Technical effort estimate: {easy_medium_complex} Competing priorities: {other_features_in_queue}
Write 2-3 user stories based on this feedback. Start each with “As a [specific customer type], I want…” Focus on the underlying need, not the specific solution customers suggested. Include story points (1-8 scale) and one acceptance criteria per story. Add a brief note explaining how this addresses the customer feedback.
When to use it: After customer research sessions or support ticket analysis when you need to convert feedback into development work.
Pro tip: Focus on the customer’s underlying job-to-be-done rather than their suggested solution. Customers are great at identifying problems but engineering teams are better at designing solutions.
You are a Product Manager writing user stories for API integration work that non-technical stakeholders need to understand.
API integration: {third_party_service_name} Business purpose: {why_this_integration_matters} Internal users affected: {roles_who_will_use_this} Data being synced: {what_information_flows} Failure scenarios: {what_happens_if_api_down} Performance requirements: {response_time_needs} Go-live deadline: {launch_date}
Create 3-4 user stories that explain this technical work in business terms. Use the format “As a [business role], I want [outcome] so that [business benefit]”. Avoid technical jargon. Include one story for error handling. Each story should be 15-20 words maximum. Add acceptance criteria that focus on user-visible outcomes, not technical implementation details.
When to use it: When you need to communicate API or backend work to executives, sales, or customer success teams in terms they understand.
Pro tip: Frame technical stories around business roles and outcomes. Instead of “implement OAuth”, write “As a sales rep, I want automatic data sync so that I don’t manually update customer records.”
You are a Product Manager writing user stories for an A/B test implementation during feature development.
Feature being tested: {feature_name} Hypothesis: {what_you_expect_to_happen} Success metric: {conversion_rate_engagement_etc} Test duration: {how_long_test_runs} Traffic split: {percentage_seeing_each_variant} Rollback plan: {what_triggers_stopping_test} Stakeholder concerns: {risks_or_objections_raised}
Write 2-3 user stories that cover building the feature with A/B testing capability. Include one story for the control group, one for the test variant, and one for measuring results. Use format “As a [user], I want [experience] so that [benefit]”. Add acceptance criteria that specify how success will be measured. Keep stories focused on user experience, not testing infrastructure.
When to use it: When you’re building features that need validation through experimentation rather than full releases.
Pro tip: Write separate stories for control and test experiences rather than one story that tries to cover both. It makes development and QA much clearer.
Acceptance Criteria and Definition of Done
You are a Product Manager writing detailed acceptance criteria for a user story that developers and QA will use for implementation and testing.
User story: {full_user_story_text} Platform: {web_mobile_desktop} User types involved: {different_roles_or_permissions} Edge cases to consider: {unusual_scenarios} Performance requirements: {load_time_or_volume_needs} Integration points: {other_systems_affected} Rollout strategy: {feature_flag_gradual_full}
Write 5-8 acceptance criteria using Given/When/Then format. Cover the happy path, error scenarios, and edge cases. Each criteria should be testable by QA without interpretation. Include one criteria for mobile responsive behavior and one for performance. End with a definition of done checklist with 4-5 items covering code review, testing, and deployment requirements.
When to use it: During backlog refinement sessions when developers need crystal-clear requirements to estimate and build stories.
Pro tip: Include at least one “unhappy path” acceptance criteria. Most bugs come from edge cases that weren’t explicitly tested during development.
You are a Product Manager defining acceptance criteria for a data-heavy feature that affects reporting and analytics.
Feature: {feature_description} Data sources: {where_data_comes_from} Reporting requirements: {who_needs_what_reports} Data accuracy needs: {acceptable_error_margins} Update frequency: {real_time_daily_weekly} Historical data: {how_far_back_needed} Compliance requirements: {gdpr_hipaa_sox_etc}
Create 4-6 acceptance criteria using Given/When/Then format. Focus on data accuracy, report availability, and user access controls. Include criteria for data validation, error handling when sources are unavailable, and audit trail requirements. Each criteria should specify measurable outcomes like “loads within 3 seconds” or “accuracy within 2%”.
When to use it: When building dashboards, reports, or analytics features where data accuracy and performance are critical.
Pro tip: Always specify data freshness requirements. “Real-time” means different things to different people. Be explicit about whether you need sub-second updates or if 15-minute delays are acceptable.
You are a Product Manager writing acceptance criteria for a feature that affects user onboarding and requires marketing team coordination.
Feature: {onboarding_feature_name} User journey stage: {signup_activation_first_value} Success metric: {completion_rate_time_to_value} Marketing materials needed: {emails_tutorials_help_docs} User segments: {free_paid_enterprise} Drop-off points: {where_users_currently_abandon} Support team training: {what_agents_need_to_know}
Write 5-7 acceptance criteria covering user experience, marketing integration, and success measurement. Use Given/When/Then format. Include criteria for different user segments, email triggers, help content availability, and analytics tracking. Add criteria for support team access to user progress data. Focus on cross-team collaboration needs.
When to use it: When building onboarding flows that require coordination between product, marketing, and customer success teams.
Pro tip: Include acceptance criteria for analytics events and email triggers. These cross-functional dependencies often get forgotten until the day before launch.
You are a Product Manager creating acceptance criteria for a security-sensitive feature that requires compliance and audit trails.
Feature: {security_feature_name} Compliance framework: {sox_gdpr_hipaa_pci} User roles affected: {admin_user_guest_permissions} Audit requirements: {what_actions_logged} Data encryption needs: {in_transit_at_rest_both} Access controls: {who_can_do_what} Incident response: {breach_notification_requirements}
Create 6-8 acceptance criteria using Given/When/Then format. Cover normal user flows, permission enforcement, audit logging, and security incident scenarios. Include criteria for data encryption, access revocation, and compliance reporting. Each criteria should be verifiable by security team review. Add specific requirements for audit trail completeness and data retention.
When to use it: When building features that handle sensitive data or require compliance with security frameworks.
Pro tip: Get security team sign-off on acceptance criteria before development starts. Security requirements discovered during QA create massive delays and often require architecture changes.
You are a Product Manager defining acceptance criteria for a performance optimization that affects existing user workflows.
Performance improvement: {what_is_being_optimized} Current performance baseline: {load_times_response_rates} Target performance goals: {specific_improvement_targets} User workflows affected: {which_actions_change} Monitoring requirements: {how_performance_measured} Rollback triggers: {what_indicates_problems} User communication: {how_users_learn_about_changes}
Write 4-6 acceptance criteria focused on measurable performance improvements and user experience validation. Use Given/When/Then format with specific metrics like “page loads in under 2 seconds” or “API responses within 200ms”. Include criteria for performance monitoring, graceful degradation, and user notification of improvements. Add rollback criteria if performance doesn’t meet targets.
When to use it: During performance sprints when you’re optimizing existing features rather than building new ones.
Pro tip: Set performance targets that are 20% better than your minimum acceptable levels. This gives buffer for real-world usage patterns that might be heavier than your test environment.
Backlog Refinement and Story Estimation
You are a Product Manager preparing user stories for estimation during backlog refinement with a development team.
Stories to estimate: {list_of_story_titles} Team velocity: {average_story_points_per_sprint} Technical context: {relevant_architecture_or_constraints} Dependencies: {other_teams_or_systems_involved} Definition of ready: {criteria_stories_must_meet} Estimation method: {planning_poker_tshirt_fibonacci} Time available: {meeting_duration}
Rewrite these stories with clear context for estimation. Add background information, technical considerations, and dependency notes. Format as: Story title, user story in standard format, key estimation factors (complexity, unknowns, dependencies), and suggested questions for the team to discuss. Keep each story block under 100 words. Order by priority for estimation discussion.
When to use it: Before refinement meetings when you need to add context that helps developers estimate accurately.
Pro tip: Include “estimation factors” that call out complexity drivers like new technology, external dependencies, or UI/UX unknowns. This speeds up estimation discussions.
You are a Product Manager splitting large user stories into smaller, sprintable pieces for immediate development.
Large story: {oversized_user_story} Story point estimate: {current_size_too_big} Sprint capacity: {available_points_next_sprint} Technical approach: {how_feature_will_be_built} User value priority: {most_important_outcomes_first} Testing requirements: {qa_considerations} Release strategy: {can_ship_incrementally_or_not}
Break this story into 3-5 smaller stories that can be completed independently. Each story should deliver user value and be estimable at 5 story points or less. Use standard “As a [user], I want [goal] so that [benefit]” format. Order by value delivery - users should get benefit from the first story completed. Include brief notes on how stories connect and what can be released incrementally.
When to use it: When planning poker reveals stories that are too large for your sprint capacity.
Pro tip: Make sure each smaller story can be demoed independently. If you can’t show working functionality after completing one story, split it differently.
You are a Product Manager prioritizing a backlog of user stories for quarterly planning with stakeholder input.
Available stories: {story_list_or_themes} Business objectives: {okrs_or_quarterly_goals} Stakeholder feedback: {sales_support_executive_input} Technical debt items: {infrastructure_or_maintenance_work} Resource constraints: {team_size_and_capacity} Market pressures: {competitive_or_customer_drivers} Revenue impact: {features_that_drive_business_results}
Rank these stories in priority order for the next quarter. Use the format: Priority ranking, story title, business justification (1-2 sentences), estimated effort, and stakeholder impact. Group related stories that should be delivered together. Include technical debt items balanced with feature work. Provide brief rationale for why lower-priority items can wait.
When to use it: During quarterly planning when you need to balance competing priorities across multiple stakeholders.
Pro tip: Use a weighted scoring model with business value, effort, and risk factors rather than gut feel. It makes priority discussions with stakeholders much more productive.
You are a Product Manager documenting story dependencies and sequencing for complex feature development.
Feature set: {related_stories_or_epic} Technical dependencies: {infrastructure_or_api_requirements} Team dependencies: {frontend_backend_devops_coordination} External dependencies: {third_party_integrations_or_approvals} User testing needs: {research_or_validation_requirements} Go-to-market timeline: {marketing_or_sales_deadlines} Risk factors: {what_could_cause_delays}
Create a story sequencing plan showing which stories must be completed before others can start. Format as: Story title, dependencies (what must finish first), estimated timeline, risk factors, and coordination needs. Identify the critical path and potential bottlenecks. Highlight stories that can be worked on in parallel. Include buffer time for testing and integration.
When to use it: When planning complex features that span multiple sprints and require careful coordination.
Pro tip: Build in 25% buffer time for integration and testing. Complex features always take longer than the sum of individual stories due to integration complexity.
You are a Product Manager updating story status and sprint progress for stakeholder reporting.
Sprint goal: {current_sprint