Innovation Pipeline

A Claude Code plugin that runs a full innovation workflow — from market opportunity screening to stress-tested offering design — in a single command.

/run CFO Manufacturing "Mid-Market ($100M–$1B revenue)"

Three rigorous tools chain together automatically. You make five consequential decisions. Everything else runs without interruption.

The Problem It Solves

Innovation and strategy work typically fragments across tools that don't talk to each other: an opportunity framework here, a design sprint there, a financial model somewhere else. Context gets lost at every handoff. Outputs don't connect.

This plugin chains three methodologies into a single run — each stage's output becomes the next stage's structured input — so you arrive at a decision-ready synthesis without rebuilding context from scratch at every step.

How It Works

Three stages run in sequence:

Stage 1 — Disruption Cascade Screens a market opportunity using ODI-based disruption analysis across 6 moves: territory mapping, disruption scoring, timing filter, build/buy/partner assessment, demand validation, and opportunity scoring. Produces a defensible Go / Conditional Go / No-Go recommendation with a thesis score.

Stage 2 — Offering Innovation Takes the screened opportunity and designs a market offering from the ground up. Uses first principles decomposition, stakeholder system mapping, ODI job mapping with external citation validation, and a diverge-then-converge design process. Every claim requires evidence. Produces a chain-of-logic offering design with competitive positioning and falsifiable proof points.

Stage 3 — Simulator Suite Stress-tests the offering design two ways simultaneously:

• Monte Carlo — probabilistic simulation (10K+ iterations) producing KPI probability distributions, sensitivity rankings, and tail risk analysis
• Customer Panel — synthetic persona deliberation (5-round structured discussion, Mom Test discipline) producing adoption signals, objection register, and forced rankings

Both run against the same offering. A synthesis document surfaces where the numbers and the personas agree — and where they diverge.

Installation

Requirements: Claude Code, Node.js, Python 3

mkdir my-run && cd my-run
npx innovation-pipeline
pip install numpy scipy pandas

Open the folder in Claude Code and type /run to start the pipeline. Run outputs save here.

Global install is not supported — the pipeline saves run artifacts into the project folder and tool framework files must live at the project root.

OpenCode

cp -r dist/opencode/. your-project/

GitHub Copilot

cp -r dist/github/.github your-project/

Gemini CLI

cp -r dist/gemini/.gemini your-project/

Codex CLI

cp -r dist/codex/.agents your-project/
mkdir -p your-project/.codex
cp -r dist/codex/.codex/agents your-project/.codex/

Trae

cp -r dist/trae/.trae/skills/* ~/.trae/skills/

Rovo Dev

# Project-specific
cp -r dist/rovo-dev/.rovodev your-project/

# Or global
cp -r dist/rovo-dev/.rovodev/skills/* ~/.rovodev/skills/

Qoder

# Project-specific
cp -r dist/qoder/.qoder your-project/

# Or global
cp -r dist/qoder/.qoder/skills/* ~/.qoder/skills/

Pi

cp -r dist/pi/.pi your-project/

Note: Claude Code is the native platform. Other CLI distributions provide system context and command definitions; full pipeline orchestration requires a CLI that supports multi-step agentic sub-agents.

Usage

/run [role] [industry] [segment]

Examples:

/run CFO Manufacturing "Mid-Market ($100M–$1B revenue)"
/run CRO Banking "Enterprise ($1B+ assets)"
/run CHRO Healthcare "Mid-Market health systems"

All outputs save to runs/run_NNN_[role_industry]/ — a versioned folder with the full artifact set from all three stages.

The Five Gates

The pipeline pauses five times for your input. These are the moments where a wrong call would require re-doing significant work. Everything between gates runs automatically.

| # | After | What You Decide | Why It Matters | |---|-------|----------------|----------------| | 1 | Stage 1, Move 1 | Confirm the target executor and territory | Every downstream stage inherits this framing | | 2 | Stage 1, Move 6 | Go / Conditional Go / No-Go | A NO-GO ends the pipeline here | | 3 | Stage 2, Phase 2 | Which executor(s) to map | Determines whose job gets designed around | | 4 | Stage 2, Phase 4 | Which offering to simulate | The simulator is built around this choice | | 5 | Stage 3 complete | Advance / Refine / Park | You close the loop |

A note on Gate 2: A Conditional Go surfaces conditions that carry forward as explicit assumptions into the offering design. They're not acknowledgments — they become Phase 1 inputs. A NO-GO terminates the run and writes a summary you can act on.

What One Run Produces

| Artifact | What It Contains | |----------|-----------------| | pipeline-log.md | Every gate decision, both handoff data blocks, and the final decision with rationale | | disruption-cascade/ | 6 move outputs, executive summary, and full audit trail | | offering-innovation/ | 4 phase outputs and a chain-of-logic executive summary | | simulator-suite/monte-carlo/ | Simulation contract, generated Python, and executive report with KPI probabilities | | simulator-suite/panel/ | Panel brief, 6 persona files, full verbatim transcript, and ranked results | | simulator-suite/synthesis.md | Cross-signal synthesis — where the numbers and the personas agree or diverge |

How the Handoffs Work

Each stage's output seeds the next via structured handoff blocks in pipeline-log.md. The orchestrator reads these explicitly at the start of each stage rather than relying on context window.

• DC → Offering: The screened executor and core job become the problem decomposition seed. Gate 2 conditions become Phase 1 assumptions.
• Offering → Simulator: Performance requirements become Monte Carlo KPI variables. The executor profile becomes the persona-building brief. The offering definition becomes the panel concept card.

No re-entering information. No rebuilding context.

The Tools Inside

Each tool also works as a standalone plugin:

| Tool | What It Does | Repo | |------|-------------|------| | Disruption Cascade | 6-move ODI-based investment thesis engine | disruption-cascade-plugin | | Offering Innovation | 5-phase problem-to-offering design pipeline | offering-innovation | | Simulator Suite | Monte Carlo + customer panel dual-signal simulator | simulator-suite-plugin |

Methodology

The pipeline draws on four frameworks:

• ODI (Outcome-Driven Innovation) — Ulwick's jobs theory for executor and outcome identification. Outcome statements follow strict format rules; 3 external citations required per gate.
• First Principles Decomposition — Structured breakdown of problem statements to atomic root causes before any design work begins.
• Design Thinking (Diverge/Converge) — Offering ideation expands unconstrained, then converges against competitive landscape and feasibility.
• Monte Carlo Simulation — Gaussian copula for correlated variables, Spearman rank correlation for sensitivity, tail risk at 5th/95th percentiles.

Validation

A deterministic test suite checks run quality across all three stages:

python tests/validate.py runs/run_001_cfo_manufacturing/
python tests/validate.py runs/run_001_cfo_manufacturing/ --stage dc
python tests/validate.py runs/run_001_cfo_manufacturing/ --stage jpo
python tests/validate.py runs/run_001_cfo_manufacturing/ --stage sim

Checks include: gate decisions logged, citation counts per phase gate, ODI outcome format compliance, MC contract schema validity, simulation code safety (no forbidden imports, cap enforcement), oracle-trap language detection in panel outputs, and synthesis completeness.

Guardrails

• Monte Carlo: Generated Python is shown before execution. Max 50,000 iterations (harness-enforced). Only numpy, scipy, pandas permitted in generated code. Max 2 retries on failure.
• Customer Panel: Oracle-trap language prohibited ("customers will..." → blocked). All panel results require a Confidence & Limitations section. Persona fidelity enforced across all 5 rounds.
• Offering design: Default is one offering — splitting requires affirmative evidence (different buyers, different value props, independent adoption). Every capability must trace to an unmet outcome.

License

MIT