product-strategy-to-ops

name: product-strategy-to-ops description: Convert product strategy artifacts (opportunity briefs, launch playbooks, growth models) into actionable bd issues with dependencies.

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:

## 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

Step 3: Extract and Create Issues

For each actionable item:

# 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:

# 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:

# 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

# 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

# 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

# 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:

# 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]