Agile Product Owner

Overview

This skill provides a complete toolkit for agile product ownership -- from backlog refinement to sprint delivery. It combines Python automation tools for story generation with collaborative practices (Example Mapping, Three Amigos, Definition of Ready) that ensure stories are well-understood before development begins.

Core Value: Reduce mid-sprint scope discovery and rework by ensuring every story meets a hard Definition of Ready gate before entering the sprint.

Target Audience: Product Owners, Business Analysts, Scrum Masters, and cross-functional teams practicing agile delivery.

Use Cases:

• Breaking epics into deliverable, INVEST-compliant user stories
• Running Example Mapping sessions to discover requirements through concrete examples
• Facilitating Three Amigos collaboration across business, development, and testing
• Enforcing Definition of Ready as a non-negotiable sprint entry gate
• Sprint planning and capacity allocation

Core Capabilities

• Story Generation - INVEST-compliant user story generator with acceptance criteria, estimation, and sprint planning
• Requirements Discovery - Example Mapping technique for collaborative specification through concrete examples
• Cross-Functional Collaboration - Three Amigos sessions bridging business, development, and testing perspectives
• Quality Gates - Definition of Ready checklist enforced as a hard gate before sprint entry
• Agile Ceremonies - Complete frameworks for planning, review, retrospective, and daily standup

Key Workflows

Workflow 1: Story Discovery and Readiness

Time: 25-minute timebox per story

Steps:

1. Select story from backlog (about to enter sprint)
2. Run Three Amigos session with business, dev, and testing representatives
3. Use Example Mapping to explore rules, examples, and questions
4. Resolve all red cards (questions) before development starts
5. Verify story against Definition of Ready checklist

Expected Output: Story with complete acceptance criteria, concrete examples, resolved questions, and DoR confirmation

References:

• Example Mapping -- card types, session flow, conversational patterns
• Three Amigos -- perspectives, anti-patterns, facilitation
• Definition of Ready -- hard gate criteria, enforcement

Workflow 2: Epic Breakdown and Sprint Planning

Time: 2-4 hours for planning; 1 hour weekly for refinement

Steps:

1. Define epic with scope and personas
2. Generate stories: python scripts/user_story_generator.py epic.json
3. Review INVEST criteria compliance
4. Run Three Amigos on each story
5. Estimate with planning poker
6. Pull stories into sprint until capacity reached

Expected Output: Sprint backlog of ready, estimated, well-understood stories

Complete toolkit for agile product ownership - from backlog refinement to sprint delivery. This skill provides Python tools for story generation, comprehensive frameworks for agile ceremonies, and battle-tested templates for user stories and epics.

What This Skill Provides:

• INVEST-compliant user story generator with sprint planning
• Complete agile ceremony frameworks (planning, review, retro)
• Velocity tracking and capacity planning methods
• Story estimation and backlog refinement processes
• Example Mapping, Three Amigos, and Definition of Ready practices

Best For:

• Breaking epics into deliverable user stories
• Sprint planning and capacity allocation
• Running effective agile ceremonies
• Tracking team velocity and burndown
• Discovering requirements collaboratively before development

Quick Start

Generate User Stories

# From sample epic
python scripts/user_story_generator.py

# From custom epic
python scripts/user_story_generator.py epic.json

# Sprint planning (30 points)
python scripts/user_story_generator.py --sprint --capacity 30

Story Quality Check

Use INVEST criteria to validate stories:

• Independent: Can complete without dependencies
• Negotiable: Flexible on implementation
• Valuable: Delivers user/business value
• Estimable: Team can size it
• Small: Fits in one sprint
• Testable: Clear success criteria

See frameworks.md for complete INVEST guidelines.

Core Workflows

1. Epic Breakdown Process

Steps:

1. Define epic with scope and personas
2. Generate stories: python scripts/user_story_generator.py epic.json
3. Review INVEST criteria compliance
4. Refine acceptance criteria
5. Prioritize and estimate with team

Epic JSON Format:

{
  "name": "User Dashboard",
  "description": "Create dashboard for users",
  "personas": ["end_user", "power_user"],
  "scope": [
    "View key metrics and KPIs",
    "Customize dashboard layout",
    "Export dashboard data"
  ],
  "technical_requirements": [
    "Implement caching for performance"
  ]
}

Detailed Process: See frameworks.md for INVEST criteria and backlog refinement.

Templates: See templates.md for epic and user story templates.

2. Sprint Planning Process

Part 1: What Will We Build? (2 hours)

1. Set sprint goal aligned with quarterly OKRs
2. Calculate team capacity (velocity x sprint days)
3. Pull stories from backlog until capacity reached
4. Identify dependencies and risks

Part 2: How Will We Build It? (2 hours)

1. Break stories into technical tasks
2. Estimate task hours
3. Assign initial owners
4. Commit to sprint scope

Sprint Planning Tool:

python scripts/user_story_generator.py epic.json --sprint --capacity 30

Detailed Framework: See frameworks.md for complete sprint planning guide.

Templates: See templates.md for sprint planning agenda.

3. Backlog Refinement Process

Weekly Activity (1 hour mid-sprint):

1. Review upcoming epics
2. Break into user stories
3. Write acceptance criteria
4. Estimate with planning poker
5. Ensure 2-3 sprints of refined backlog

Estimation Scale:

• 1-2 points: Simple (2-4 hours)
• 3-5 points: Moderate (1-3 days)
• 8 points: Complex (3-5 days)
• 13+ points: Too large - needs breakdown

Detailed Process: See frameworks.md for refinement and estimation methods.

Templates: See templates.md for story templates and splitting techniques.

Python Tools

user_story_generator.py

INVEST-compliant story generator with sprint planning.

Key Features:

• Epic breakdown into user stories
• Automatic acceptance criteria generation
• Story point estimation
• INVEST criteria validation
• Sprint capacity planning
• Multiple output formats (text, JSON, CSV)

Usage:

# Basic story generation
python3 scripts/user_story_generator.py epic.json

# Sprint planning
python3 scripts/user_story_generator.py --sprint --capacity 30

# JSON output for Jira import
python3 scripts/user_story_generator.py -o json -f stories.json

# CSV for spreadsheet import
python3 scripts/user_story_generator.py -o csv -f backlog.csv

# Verbose mode (show all stories)
python3 scripts/user_story_generator.py -v

Story Point Estimation:

• 1 pt: Simple, basic, view (2-4 hours)
• 3 pts: Create, edit, update (1 day)
• 5 pts: Moderate complexity (2-3 days)
• 8 pts: Complex, integrate (3-5 days)
• 13 pts: Redesign, refactor (1-2 weeks, needs breakdown)

Complete Documentation: See tools.md for full usage guide, input formats, and integration patterns.

Reference Documentation

Frameworks (frameworks.md)

Comprehensive agile methodologies:

• INVEST Criteria: Detailed guidelines for each criterion
• Sprint Planning: Two-part planning framework
• Sprint Review & Retrospective: Complete ceremony guides
• Daily Standup: Three questions format and anti-patterns
• Backlog Refinement: Estimation and prioritization
• Velocity Tracking: Calculation, trends, burndown charts
• Release Planning: Capacity and timeline forecasting

Templates (templates.md)

Ready-to-use templates:

• User Story Templates: Standard, feature, technical, bug fix formats
• Epic Templates: Complete epic structure with examples
• Sprint Ceremony Agendas: Planning, review, retrospective formats
• Story Splitting Techniques: By workflow, business rules, data entry
• Best Practices: Writing effective stories and avoiding pitfalls

Tools (tools.md)

Python tool documentation:

• user_story_generator.py: Complete usage guide
• Input Formats: Epic JSON structure
• Output Formats: Text, JSON, CSV examples
• Command-Line Options: All flags and parameters
• Integration Patterns: Jira, Linear, ProductBoard workflows
• Troubleshooting: Common issues and solutions
• Best Practices: DO/DON'T guidelines

Consolidated References

The following references were consolidated from BDD requirements discovery methodology:

| Reference | Content | When to Load | |-----------|---------|--------------| | Example Mapping | Four card types, session flow, conversational patterns, output artifacts, anti-patterns | Story about to enter sprint; team uncertain about scope; cross-functional clarification needed | | Three Amigos | Three perspectives (business/dev/test), session structure, cadence, confirmation bias defense, anti-patterns | Backlog refinement; before sprint planning; after significant scope change | | Definition of Ready | Hard gate criteria, requirements completeness (functional/NFR/business rules), quality review dimensions, enforcement without bureaucracy | Verifying story readiness before sprint entry; establishing team standards |

Additional references (story decomposition and workshops)

The following references extend story decomposition and workshop execution patterns:

| Reference | Content | When to Load | |-----------|---------|--------------| | Story Splitting Patterns | SPIDR and practical splitting patterns with before/after examples | Stories are too large or carry hidden coupling | | Epic Breakdown Patterns | Epic decomposition, dependency mapping, and vertical slicing heuristics | Planning a delivery sequence from a broad initiative | | Epic Hypothesis Format | Hypothesis-driven epic framing with measurable outcomes | Defining epics that need testable business outcomes | | Story Mapping Workshop | Story mapping method plus facilitation protocol for release slicing | Running collaborative story mapping sessions with cross-functional teams |

Integration Points

This toolkit integrates with:

• Project Management: Jira, Linear, Azure DevOps, Asana
• Collaboration: Confluence, Notion, Miro
• Version Control: GitHub Issues, GitLab Issues
• Roadmapping: ProductBoard, Aha!, Roadmunk

See tools.md for detailed integration workflows.

Quick Commands

# Generate stories from sample
python scripts/user_story_generator.py

# Generate from custom epic
python scripts/user_story_generator.py epic.json

# Sprint planning (30 points)
python scripts/user_story_generator.py --sprint --capacity 30

# Export as JSON
python scripts/user_story_generator.py -o json -f stories.json

# Export as CSV
python scripts/user_story_generator.py -o csv -f backlog.csv

# Verbose output (all stories)
python scripts/user_story_generator.py -v