# Product Strategy To Ops

> Convert product strategy artifacts (opportunity briefs, launch playbooks, growth models) into actionable bd issues with dependencies.

- Skill: `tjboudreaux/product-strategy-to-ops` (Agent Skill)
- Install (CLI): `npx skillmds@latest add tjboudreaux/product-strategy-to-ops`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tjboudreaux/product-strategy-to-ops/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Marketing & Growth
- Author: tjboudreaux (https://skillmd.com/u/tjboudreaux)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/tjboudreaux/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]
```