OpenSpec + Superpowers Fusion: The New Spec-Driven Coding Bridges

Here's the uncomfortable statistic of 2026's AI coding: roughly 22% of AI-generated PRs fail at the code level — not because the model can't write code, but because the plan and the execution never connected. The planning tool produces a spec, the agent goes off and does something adjacent to it, and nobody notices until the diff arrives. The community named this the planning-execution gap, and it spawned the year's most interesting trend: fusion projects that bolt OpenSpec's planning onto Superpowers' execution discipline.

Three open-source projects lead the fusion wave: spec-superflow, superspec, and spec-driven-tdd.

Why fusion happened

OpenSpec is a great planner and stops there — its spec store ends at tasks.md, with no opinion about how code gets written. Superpowers is relentless execution discipline — TDD as an iron rule, review gates — but its planning is a brainstorm discussion, not a formal spec. Each project leaves exactly the half the other covers. The gap between them is where the 22% failure rate lives: a spec that was never enforced, or discipline with no requirements to hold it to.

Fusion projects are the connective tissue: OpenSpec produces the contract, Superpowers executes it, and the bridge makes sure execution can't quietly drift from the contract.

The three bridges

spec-superflow

The most complete of the three — a Claude Code plugin (MIT, v0.9 by mid-2026) that fuses OpenSpec's four-stage planning with Superpowers' execution skills, running on a source-level merge rather than a wrapper.

Its core innovation is the bridge contract: the plugin automatically extracts six elements from the planning artifacts — Intent Lock, Scope Fence, Non-Goals, Test Obligations, Review Gates, and Rewind Triggers — and feeds them to the execution phase. The agent isn't just told "implement the spec"; it's told what it must not touch, what tests it owes, which gates it will be checked against, and when to rewind.

The workflow runs as an 8-state machine: exploring → specifying → bridging → approved-for-build → executing ⇄ debugging → closing → abandoned. State transitions carry the review gates: approved-for-build is a hard gate before any code is written, and every executing → closing transition requires the spec obligations to be met.

Zero external dependencies, supports 7–17 agent platforms depending on version, and includes fast paths for hotfixes, tweaks, and full features.

superspec

A different integration style: superspec uses OpenSpec as the orchestrator and calls Superpowers skills as the execution engine. Six stages: Brainstorm → artifact creation → code implementation → spec verification → wrap-up → archive. Each stage invokes the appropriate Superpowers skill, so the idea-to-archive chain stays traceable end to end: every artifact links back to the spec delta that produced it.

spec-driven-tdd

The lightweight member of the family: a multi-harness skill-pack (works with Claude Code and other agents) that fuses OpenSpec planning/task tracking with Superpowers' TDD, simplify, and code-review skills. Four-stage loop: PLAN → ISOLATE → IMPLEMENT → FINISH — and its definition of done is distinctive: a task is finished when it gets a clean review, not when tests go green. Tests passing is table stakes; the review gate is the standard.

What the bridges change in practice

| | Spec alone | Discipline alone | Fused | |---|---|---|---| | Requirements | Versioned delta specs | Design discussion | Delta specs as the contract | | Execution | Whatever the agent does | TDD + review gates | TDD + gates against the spec | | Drift detection | None until review | N/A (no contract) | Scope fence + review gates catch it during work | | Failure mode | Spec ignored in practice | Discipline without direction | Residual: bridge contract quality |

The fused workflow's answer to "the agent drifted" is not a better review — it's that the agent is told, before writing code, exactly what the boundaries are (Intent Lock, Scope Fence), and the review gates check the obligations, not the vibes.

Should you use a fusion project?

Yes, if: you've already decided OpenSpec-style planning and Superpowers-style execution both appeal, and you'd rather have one integrated loop than maintain two tools and the discipline to keep them honest yourself.

Maybe not, if: you're early in adopting spec-driven coding at all. Fusion projects are built on two dependencies' philosophies, and their fast-moving version numbers (v0.x) mean the integration layers shift. Start with the specdd skill to try the methodology, move to OpenSpec or Spec Kit for a stable planning layer, and consider fusion once the planning-execution gap is the specific problem you can name.

For the broader ecosystem map, start at the complete spec-driven coding guide; for the philosophical debate the bridges are trying to settle, see spec-driven vs vibe coding.