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

code

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

code

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

code

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]