product-strategy-to-ops

# Strategy to Ops Conversion ## Overview This skill bridges the gap between strategic product work and operational execution. When product-* skills produce strategy artifacts (opportunity briefs, launch playbooks, value propositions), this skill converts actionable items into tracked bd issues with proper typing, prioritization, and dependencies. ## When to Use - After `product-opportunity-mapping` produces an opportunity brief - After `product-launch-ops` produces a launch playbook - After `product-growth-loops` produces experiment blueprints - After `product-value-proposition` produces validation plans - After `product-monetization` produces economic models - When you have strategy documents that need execution tracking ## Input Artifact Types ### 1. Opportunity Brief **Source**: `product-opportunity-mapping` **Contains**: User tensions, evidence, unknowns, experiments **Extractable items:** - Experiments to validate assumptions → `task` issues - Research to reduce unknowns → `task` issues - Technical spikes → `task` issues ### 2. Launch Playbook **Source**: `product-launch-ops` **Contains**: Hypotheses, rollout stages, risks, metrics **Extractable items:** - Rollout stage gates → `epic` with child `task` issues - Risk mitigations → `task` issues - Instrumentation needs → `task` issues - Comms/docs work → `task` issues ### 3. Growth Model **Source**: `product-growth-loops` **Contains**: Loop definitions, experiments, metrics **Extractable items:** - Loop implementation steps → `epic` with child issues - A/B tests → `task` issues - Instrumentation → `task` issues - Guardrail monitors → `task` issues ### 4. Value Proposition **Source**: `product-value-proposition` **Contains**: Promise variants, artifacts, signal tests **Extractable items:** - Prototype builds → `task` issues - User tests → `task` issues - Landing page experiments → `task` issues ### 5. Monetization Model **Source**: `product-monetization` **Contains**: Value exchanges, economic models, experiments **Extractable items:** - Pricing experiments → `task` issues - Payment integration → `feature` issues - Compliance checks → `task` issues ## Conversion Workflow ### Step 1: Parse Strategy Document Identify actionable sections: ```markdown ## Sections to Extract From ### "Unknowns & Experiments" section - Each experiment → bd issue ### "Risks & Mitigations" section - Each mitigation → bd issue (if actionable) ### "Next Steps" section - Each step → bd issue ### "Validation Plan" section - Each test → bd issue ### "Implementation Order" section - Sequence defines dependencies ``` ### Step 2: Determine Issue Types | Strategy Item | bd Type | Priority Heuristic | |---------------|---------|-------------------| | Validate core assumption | `task` | P1 (blocks everything) | | User research | `task` | P1-P2 | | Technical spike | `task` | P1-P2 | | Build prototype | `task` | P2 | | A/B test | `task` | P2 | | Launch stage | `epic` | P1 | | Risk mitigation | `task` | P0 if critical, P2 otherwise | | Instrumentation | `task` | P1 (needed for measurement) | | Documentation | `task` | P3 | ### Step 3: Extract and Create Issues For each actionable item: ```bash # Template for strategy-derived issues bd create "[Strategy] <action verb> <specific item>" \ --description="## Source From: [Strategy Document Name] Section: [Section Name] ## Context [Why this matters from strategy perspective] ## Definition of Done - [ ] [Specific completion criteria] - [ ] [Measurable outcome] ## Success Metrics [How we know this worked] " \ --type task \ --priority 2 \ --label strategy,<source-skill> \ --json ``` ### Step 4: Establish Dependencies Dependencies reflect strategic sequencing: ```bash # Validation before implementation bd dep add bd-impl bd-validation --type blocks # Instrumentation before experiments bd dep add bd-experiment bd-instrumentation --type blocks # Risk mitigation before launch bd dep add bd-launch bd-risk-mitigation --type blocks ``` ### Step 5: Create Strategy Epic Group related issues under a strategy epic: ```bash # Create umbrella epic EPIC_ID=$(bd create "[Strategy Epic] <Strategy Name>" \ --description="Tracks execution of <Strategy Document> ## Source Document [Link or path to strategy artifact] ## Key Hypotheses 1. [Hypothesis 1] 2. [Hypothesis 2] ## Success Criteria - [Metric] reaches [target] " \ --type epic \ --priority 1 \ --label strategy \ --json | jq -r '.id') # Child issues become subtasks bd dep add bd-child-1 $EPIC_ID --type parent-child bd dep add bd-child-2 $EPIC_ID --type parent-child ``` ## Conversion Templates ### Opportunity Brief → Issues ```bash # For each "Unknown" in the brief bd create "[Research] Validate assumption: <assumption>" \ --description="## Assumption <The assumption to validate> ## Evidence Needed <What would prove/disprove this> ## Methods - [ ] User interviews (n=5-8) - [ ] Data analysis - [ ] Competitive research ## Source Opportunity Brief: <name> " \ --type task --priority 1 --label strategy,research --json # For each "Experiment" bd create "[Experiment] Test: <hypothesis>" \ --description="## Hypothesis If <change>, then <metric> will <improve> because <reason> ## Test Design - Variant A: <control> - Variant B: <treatment> - Sample: <size> - Duration: <time> ## Success Criteria <metric> improves by <threshold> with p < 0.05 ## Source Opportunity Brief: <name> " \ --type task --priority 2 --label strategy,experiment --json ``` ### Launch Playbook → Issues ```bash # For each rollout stage bd create "[Launch] Stage N: <stage name>" \ --description="## Stage Definition Audience: <who> Duration: <time> Entry criteria: <conditions> ## Exit Criteria - [ ] <metric 1> stable - [ ] <metric 2> above threshold - [ ] No P0 bugs ## Rollback Trigger <when to revert> ## Source Launch Playbook: <name> " \ --type epic --priority 1 --label strategy,launch --json # For each risk bd create "[Risk Mitigation] <risk name>" \ --description="## Risk <description> ## Likelihood <High/Medium/Low> ## Impact <High/Medium/Low> ## Mitigation <specific action> ## Verification How to confirm mitigation works ## Source Launch Playbook: <name> " \ --type task --priority $([ "$LIKELIHOOD" = "High" ] && echo 0 || echo 2) \ --label strategy,risk --json ``` ### Growth Loop → Issues ```bash # For the loop implementation bd create "[Growth] Implement loop: <loop name>" \ --description="## Loop Definition Trigger: <what starts it> Action: <user behavior> Reward: <what user gets> Investment: <commitment that improves loop> ## Implementation Steps 1. <step> 2. <step> ## Metrics - Loop completion rate - Time between iterations - Retention impact ## Source Growth Model: <name> " \ --type epic --priority 1 --label strategy,growth --json # For each experiment bd create "[Growth Experiment] <experiment name>" \ --description="## Hypothesis <statement> ## KPIs - Primary: <metric> - Guardrails: <metrics that shouldn't degrade> ## Design <experiment setup> ## Source Growth Model: <name> " \ --type task --priority 2 --label strategy,growth,experiment --json ``` ## Validation Checklist Before marking conversion complete: - [ ] All "Next Steps" from strategy doc have corresponding issues - [ ] All "Experiments" have issue with hypothesis and success criteria - [ ] All "Risks" (High/Medium) have mitigation issues - [ ] Dependencies reflect strategic sequencing - [ ] Labels include `strategy` and source skill name - [ ] Epic exists to track overall strategy execution - [ ] Original strategy doc is linked in descriptions ## Post-Conversion After creating issues: ```bash # Verify structure bd dep tree $EPIC_ID # Check for cycles (shouldn't have any) bv --robot-insights --json | jq '.cycles' # Get execution plan bv --robot-plan --json | jq '.parallel_tracks' # Update strategy doc with issue links echo "## Tracking Issues" >> docs/strategy/<doc>.md echo "Epic: $EPIC_ID" >> docs/strategy/<doc>.md bd list --label strategy --json | jq -r '.[] | "- [\(.id)] \(.title)"' >> docs/strategy/<doc>.md ``` ## Integration with Product Skills ### After product-opportunity-mapping ``` 1. Run product-opportunity-mapping → Opportunity Brief 2. Run product-strategy-to-ops on brief → bd issues 3. Use bv --robot-priority to sequence ``` ### After product-launch-ops ``` 1. Run product-launch-ops → Launch Playbook 2. Run product-strategy-to-ops on playbook → bd issues 3. Use bv --robot-plan for parallel tracks ``` ### Full Strategy Cycle ``` product-opportunity-mapping ↓ product-value-proposition ↓ product-growth-loops + product-monetization ↓ product-launch-ops ↓ product-strategy-to-ops (this skill) ↓ bd + bv for execution ↓ product-behavior-signals (measure) ↓ [repeat cycle] ```