A side-by-side look at two of the most influential frameworks for structured, agentic AI coding — plus a step-by-step playbook for using them together:

• github/spec-kit — GitHub's toolkit for Spec-Driven Development (SDD).
• obra/superpowers — Jesse Vincent's agentic skills framework for disciplined agent-driven development.

Both projects address the same underlying problem — AI coding agents are powerful but unstructured — but they solve it from very different angles. Spec Kit treats the specification as the source of truth; Superpowers treats the development workflow as the source of truth.

📑 Table of Contents

• ⚡ TL;DR
• 1. 🧠 Philosophy
• 2. 🔄 Workflow & Mental Model
• 3. 🏗️ Architecture & Primary Unit
• 4. 🤖 Agent / Tool Compatibility
• 5. 📦 Installation & Distribution
• 6. 🧩 Customization & Extensibility
• 7. 🌟 What Each Does Especially Well
• 8. ⚖️ Tradeoffs & Limitations
• 9. 🤝 How They Could Coexist
• 9a. 🛠️ The Best Way to Combine Both — A Practical Guide
  • ⚙️ One-time setup
  • 🔁 The per-feature loop
  • 📜 Two non-obvious rules
  • 📋 Handoff prompt template
  • 📏 When to scale down
  • 🚫 Anti-patterns to avoid
  • ✅ 60-second checklist
• 10. 🧭 Quick Decision Guide
• 11. 📊 At-a-Glance Summary

⚡ TL;DR

1. 🧠 Philosophy

📘 Spec Kit — "The spec is the source of truth"

Spec Kit flips the traditional flow: instead of writing code that loosely tracks a spec, the spec directly generates the implementation. Changes happen at the spec layer first; code is regenerated to match. Quoting the README: "specifications become executable, directly generating working implementations rather than just guiding them."

Foundational principles:

• Intent first — what & why before how
• Rich, guard-railed specifications with organizational principles
• Multi-step refinement instead of one-shot generation
• AI-native workflows that lean on advanced model capabilities

🦸 Superpowers — "The workflow is the source of truth"

Superpowers prevents agents from immediately jumping into code. It enforces a disciplined sequence: discovery → design validation → planning → implementation → review → completion. From the README: "As soon as it sees that you're building something, it doesn't just jump into trying to write code."

Four core principles:

• Test-Driven Development — tests precede all code
• Systematic over ad-hoc — process replaces guessing
• Complexity reduction — simplicity is the primary goal
• Evidence over claims — verify before declaring success

🔀 The philosophical split

• Spec Kit is artifact-centric. The spec persists, evolves, and is the contract.
• Superpowers is process-centric. The procedure persists; the artifact is whatever the procedure produces.

2. 🔄 Workflow & Mental Model

📘 Spec Kit's 7-step workflow

1. /speckit.constitution — Establish project governing principles
2. /speckit.specify — Define requirements and user stories
3. /speckit.clarify — Clarify underspecified requirements
4. /speckit.plan — Create technical implementation plans
5. Validate the plan for completeness
6. /speckit.tasks — Generate actionable task breakdowns
7. /speckit.implement — Execute tasks to build features

Three modes: 0-to-1 (greenfield), Creative Exploration (parallel implementations across stacks), Iterative Enhancement (brownfield).

🦸 Superpowers' 7 workflow stages

1. Brainstorming — Socratic questioning to refine ideas
2. Using Git Worktrees — Isolated branches with verified test baselines
3. Writing Plans — Break work into 2–5 minute tasks with exact specs
4. Subagent-Driven Development — Fresh subagent per task, two-stage review
5. Test-Driven Development — Strict RED-GREEN-REFACTOR
6. Requesting Code Review — Pre-review checklists, severity-based tracking
7. Finishing Development Branches — Merge/PR decision + cleanup

🎯 Key contrast

• Spec Kit's workflow is linear and document-producing: each command emits an artifact (constitution, spec, plan, tasks).
• Superpowers' workflow is stateful and execution-producing: each stage manipulates code, tests, branches, and subagent state.

3. 🏗️ Architecture & Primary Unit

📘 Spec Kit — Slash commands + templates

Six explicit, user-invoked slash commands (/speckit.constitution, /speckit.specify, /speckit.clarify, /speckit.plan, /speckit.tasks, /speckit.implement). Each is a template that produces a structured artifact stored under .specify/.

.specify/
├── memory/         # Constitution and governance
├── specs/          # Feature specifications by ID
├── scripts/        # Helper automation scripts
├── extensions/     # Custom extensions
├── presets/        # Workflow customizations
└── templates/      # Command templates

🦸 Superpowers — Skills + agents + plugins

14+ composable skills organized by category:

• Testing: test-driven-development
• Debugging: systematic-debugging, verification-before-completion
• Collaboration: brainstorming, writing-plans, executing-plans, dispatching-parallel-agents, requesting-code-review, receiving-code-review, using-git-worktrees, finishing-a-development-branch, subagent-driven-development
• Meta: writing-skills, using-superpowers

agents/        # Agent definitions
skills/        # Skill implementations (auto-triggered)
commands/      # CLI command definitions
.claude-plugin/, .codex-plugin/, .cursor-plugin/   # Per-host configs

🎬 Trigger model — the deepest difference

• Spec Kit: human types /speckit.plan. Explicit, deterministic.
• Superpowers: skill auto-fires when its description matches the situation. The agent doesn't decide to brainstorm; the brainstorming skill triggers because the user mentioned a vague idea.

This makes Spec Kit feel like a CLI you drive, and Superpowers feel like an operating system the agent inhabits.

4. 🤖 Agent / Tool Compatibility

Spec Kit casts a wider net (30+ agents), selected at install time via --integration. Superpowers goes deeper per host, with first-class plugin packages tailored to each ecosystem.

5. 📦 Installation & Distribution

📘 Spec Kit

uv tool install specify-cli --from git+https://github.com/github/spec-kit.git@vX.Y.Z

• Python 3.11+, Git, uv or pipx
• Cross-platform (Linux/macOS/Windows)
• Distributed only from GitHub — PyPI packages with the same name are not official

🦸 Superpowers

• Claude plugin marketplace: /plugin install superpowers@claude-plugins-official
• Superpowers marketplace registration
• Per-agent installation flows for Codex, Cursor, OpenCode, Copilot CLI, Gemini CLI

Spec Kit is a single CLI you install once and configure per project. Superpowers is a plugin you install per agent host, with the host's plugin system managing updates.

6. 🧩 Customization & Extensibility

📘 Spec Kit

• Extensions — add new capabilities (Jira sync, post-implementation review, …)
• Presets — customize existing workflows (compliance formats, terminology localization)
• 100+ community-contributed extensions across docs, code, process, integration, visibility categories

🦸 Superpowers

• Skills are the extension primitive — write your own SKILL.md with a description that triggers in your situation
• The writing-skills meta-skill teaches the agent how to author new skills
• using-superpowers documents how skills compose

🔍 Comparison

• Spec Kit's extension model is catalog-driven — you browse and adopt prebuilt pieces.
• Superpowers' extension model is author-driven — the framework actively supports you writing the next skill.

7. 🌟 What Each Does Especially Well

📘 Spec Kit shines when…

• You need traceability from requirement to code (audits, compliance, regulated industries)
• A product manager / non-engineer owns the spec and engineers consume it
• You want to swap stacks: regenerate the same spec into Go, Python, TypeScript
• Your org already thinks in terms of PRDs, RFCs, and design docs
• You need enterprise-style governance with constitution-level constraints

🦸 Superpowers shines when…

• You want the agent to run autonomously for hours without going off-rails
• You want strict TDD baked into the agent's behavior, not just hoped for
• You're orchestrating parallel subagents and need built-in review patterns
• You need evidence-based completion — agent must prove it worked, not claim it
• You're operating at the frontier of agent autonomy and want guardrails by default

8. ⚖️ Tradeoffs & Limitations

📘 Spec Kit

• Heavier upfront cost — writing a constitution and spec before any code feels slow for small tasks
• Less suited for exploratory hacking — the workflow assumes you know roughly what you want
• Spec drift risk — if the team edits code without updating specs, the "single source of truth" erodes
• Document-heavy — generates many markdown artifacts that need maintenance

🦸 Superpowers

• Opinionated — the workflow assumes you want TDD, worktrees, subagent orchestration; if you don't, friction is high
• Complexity floor — even small tasks pay some procedural overhead
• Learning curve — 14+ skills and a meta-vocabulary (subagent-driven-development, verification-before-completion) take time to internalize
• Auto-triggering can surprise — a skill firing unexpectedly can derail a session if descriptions are loose

9. 🤝 How They Could Coexist

These are not mutually exclusive. A team could realistically:

• Use Spec Kit for the what — constitution, spec, plan, tasks committed to the repo as durable artifacts
• Use Superpowers for the how — once tasks exist, Superpowers' TDD, worktree, subagent, and review skills execute them

The artifacts Spec Kit produces (.specify/specs/<id>/tasks.md) are exactly the kind of plan Superpowers' executing-plans skill is designed to consume. The two systems target different layers of the same problem.

9a. 🛠️ The Best Way to Combine Both — A Practical Guide

The mental model in one sentence:

Spec Kit plans WHAT to build. Superpowers controls HOW it gets built.

Spec Kit gives you durable, human-readable artifacts (constitution → spec → plan → tasks). Superpowers takes those tasks and executes them with TDD, worktrees, subagents, and review baked in. You hand off at the task list.

⚙️ One-time setup (do this once per machine + once per repo)

On your machine:

1. Install Spec Kit:

   uv tool install specify-cli --from git+https://github.com/github/spec-kit.git

1. Install Superpowers in your agent host. For Claude Code:

   /plugin install superpowers@claude-plugins-official

In your repo (once):

1. Initialize Spec Kit with your agent: specify init --integration claude-code (or whichever agent you use).
2. Run /speckit.constitution once to set project-wide rules. Add a single line that bridges the two systems: > "Implementation of any task list MUST follow the Superpowers workflow: worktree → TDD (red-green-refactor) → subagent-driven execution → code review → finish-branch."
3. Commit .specify/ to the repo. Add .claude/ (or your host's plugin dir) per your team's policy.

That's the entire setup. From here on, every feature follows the same loop.

🔁 The per-feature loop (the one you actually use)

Run these in order. Each step is a single command or short prompt.

That's it. Spec Kit owns steps 2–5. Superpowers owns steps 1, 6–9. The handoff happens at tasks.md.

📜 The two non-obvious rules that make this combo work

Rule 1 — Don't skip /speckit.tasks, even when you're tempted.
Superpowers' executing-plans skill is designed to consume small (2–5 minute) tasks. Spec Kit's /speckit.tasks produces exactly that shape. Skipping it forces Superpowers to break the work down at execution time, which is slower and lower quality.

Rule 2 — Don't let Superpowers re-plan what Spec Kit already planned.
When you start step 7, explicitly say: "The plan is already in specs/<id>/tasks.md. Don't re-plan — execute." Otherwise Superpowers' writing-plans skill may auto-fire and duplicate work.

📋 One-line prompt template for the execution handoff

Paste this when you're ready to switch from Spec Kit (planning) to Superpowers (execution):

Execute specs/<feature-id>/tasks.md using the Superpowers workflow:
create a worktree, follow strict TDD per task, dispatch one subagent per
task, run code review at the end, then finish the branch. Do not re-plan —
the task list is the contract.

📏 When to scale down (don't over-engineer small work)

For a one-line bug fix or a typo, both frameworks are overkill. A reasonable size cutoff:

🚫 Anti-patterns to avoid

• ❌ Running /speckit.implement AND Superpowers. Pick one for execution. /speckit.implement is Spec Kit's own executor; Superpowers replaces it for this combo.
• ❌ Editing code without updating the spec. If reality diverges from spec.md, your audit trail dies. Re-run /speckit.specify for the changed area.
• ❌ Letting subagents read the whole .specify/ tree. Pass them only the specific task they're executing — context discipline still matters.
• ❌ Skipping the constitution. Without it, Superpowers and Spec Kit each impose their own defaults and you'll feel the friction.

✅ A 60-second mental checklist before starting any feature

1. Is there a spec? If no → /speckit.specify.
2. Are tasks small and ordered? If no → /speckit.tasks.
3. Am I on a worktree with green tests? If no → trigger using-git-worktrees.
4. Did I tell the agent "don't re-plan, execute"? If no → say it now.
5. Will I review the PR diff myself before merging? If no → stop.

If all five are yes, you're using the combo correctly.

10. 🧭 Quick Decision Guide

📘 Pick Spec Kit if you…

• Want specs as durable, reviewable artifacts
• Need cross-stack portability (regenerate same spec → different language)
• Work in an environment where PRDs/RFCs are already a norm
• Value broad agent compatibility (30+ tools)
• Want a GitHub-backed, enterprise-friendly project

🦸 Pick Superpowers if you…

• Want the agent itself to behave more like a senior engineer
• Need strict TDD, worktree isolation, subagent orchestration out of the box
• Run long, autonomous sessions and need guardrails
• Prefer auto-triggered skills over user-invoked commands
• Want a writable, composable skill system you can extend yourself

🤝 Pick both if you…

• Want artifact-driven planning + workflow-driven execution
• Are willing to invest in setup for a more rigorous overall pipeline

11. 📊 At-a-Glance Summary

Generated 2026-04-25. Both projects are evolving rapidly — verify version-specific details against their READMEs before adopting.

If you found this helpful, let me know by leaving a 👍 or a comment!, or if you think this post could help someone, feel free to share it! Thank you very much! 😃