Agile Product Owner

/agile-product-owner

Complete toolkit for Product Owners to excel at backlog management and sprint execution. Ask the user to paste the epic, requirements, or backlog they are working with, plus team capacity if they want sprint-fitting.

Core Capabilities

• INVEST-compliant user story generation
• Automatic acceptance criteria creation
• Sprint capacity planning
• Backlog prioritization
• Velocity tracking and metrics

Generating User Stories from Epics

Given an epic or a feature description, break it into well-formed stories:

1. Identify the actors: Who touches this feature? (end user, admin, system, support)
2. Slice vertically: Each story should deliver a thin end-to-end slice of value, not a technical layer.
3. Write in standard form:

   As a [role]
   I want [capability]
   So that [benefit]
   

4. Attach acceptance criteria (see below).
5. Estimate points and assign a priority.

INVEST Validation

Check every story against INVEST before it enters the backlog:

• Independent: Can be built and shipped without waiting on another story
• Negotiable: Captures intent, not a fixed implementation contract
• Valuable: Delivers observable value to a user or stakeholder
• Estimable: The team can size it with reasonable confidence
• Small: Fits comfortably within one sprint (split it if not)
• Testable: Has criteria that can be verified objectively

If a story fails a criterion, name the failing letter and propose the fix (split, clarify the value, add missing detail).

Acceptance Criteria

Write criteria in Given/When/Then form, 3-6 per story:

Given [precondition]
When [action]
Then [observable result]

Also cover:

• The happy path
• At least one edge case or error state
• Any permission/role constraints
• Non-functional constraints when relevant (performance, accessibility)

Point Estimation

Use a Fibonacci-style scale (1, 2, 3, 5, 8, 13):

• 1-2: Trivial change, well understood, one component
• 3-5: Moderate complexity or touches multiple components
• 8: Large, uncertain, or cross-team; consider splitting
• 13: Too big; must be split before sprint commitment

Estimate relative to previously sized stories, not in hours.

Backlog Prioritization

Assign each story a priority based on:

1. Value: Business or user impact
2. Urgency: Deadlines, dependencies, decay of value
3. Risk reduction: Does it retire uncertainty early?
4. Cost: Points estimated

Order the backlog so the top is always ready: highest value-per-point first, dependencies resolved, stories INVEST-clean. Keep roughly two sprints of refined stories at the top; leave lower items coarse.

Sprint Planning with Capacity

Given a capacity in points (ask the user for team velocity or capacity):

1. Take stories from the top of the prioritized backlog.
2. Add stories until the next one would exceed capacity.
3. Never split a commitment mid-story to hit the number; leave slack instead.
4. Flag any committed story with unresolved dependencies.

Output a proposed sprint list with total points, remaining slack, and any risks.

Velocity Tracking

Track per sprint: committed points, completed points, carry-over. Use the rolling average of the last 3 sprints as planning velocity. Watch for:

• Velocity variance beyond +/-10% (estimation or scope problem)
• Chronic carry-over (stories too big or capacity overstated)
• Rising unplanned work share (backlog not reflecting reality)

Output Format

When generating stories, deliver:

## Epic: [name]

### Story 1: [title]
As a [role], I want [capability], so that [benefit].
- Points: [n] | Priority: [High/Medium/Low]
- INVEST check: [pass, or failing letters with fix]

Acceptance Criteria:
- Given ... When ... Then ...
- Given ... When ... Then ...

### Story 2: ...

## Sprint Proposal (capacity: [n] points)
1. [story] ([points])
2. ...
Total: [n]/[capacity] points

Usage

/agile-product-owner $ARGUMENTS