2026 AI Specification Frameworks Compared: OpenSpec, Spec Kit, Superpowers, BMAD & GSD

Aug 8, 2026

The problem

When I started planning my 2026 feature work with AI coding agents, I ran into a wall: five projects all claimed to make AI write better software, and I could not tell them apart. OpenSpec, GitHub Spec Kit, Superpowers, BMAD Method, and GSD Core all live in the same “spec-driven development” space, but they sit at different layers and enforce very different amounts of process.

Here is the direct answer for this AI specification framework comparison: there is no single best framework in 2026. OpenSpec is a lightweight, vendor-neutral spec format. GitHub Spec Kit is an opinionated Spec-Driven Development (SDD) toolkit with a specify CLI. Superpowers is a skills-library plugin, not a spec format. BMAD Method is a full phase-gated agile methodology. GSD Core is a context-engineering framework that enforces a phase loop. You pick by project size, how much enforcement you want, and which coding agent you run.

What is an AI specification framework?

A specification framework is a format plus a workflow that makes humans and AI agree on what to build before the AI writes code. Without it, requirements live only in chat history, and the agent turns unstated assumptions into working code.

These five projects are often lumped together, but they are not the same kind of thing:

Specification frameworks (a portable spec format): OpenSpec, GitHub Spec Kit
Full project methodologies (idea → code, phase-gated): BMAD Method, GSD Core
Skills / workflow layer (not a spec schema): Superpowers

This is the first thing to check before comparing them. Comparing OpenSpec to BMAD is like comparing a file format to a project management office.

Portable spec format:  OpenSpec, GitHub Spec Kit
Skills library:        Superpowers
Full methodology:      BMAD Method, GSD Core

The five at a glance

Project	What it really is	One-line summary
OpenSpec	Portable spec format	Align humans + AI on what to build, across 30+ agents
GitHub Spec Kit	SDD toolkit + format	GitHub’s opinionated harness with a `specify` CLI
Superpowers	Skills library plugin	A disciplined dev workflow layered on your agent
BMAD Method	Full agile methodology	Idea → code with phase gates and persona agents
GSD Core	Context-engineering framework	Enforced phase loop that fights context degradation

OpenSpec — lightweight spec format

Repo: github.com/Fission-AI/OpenSpec

Positioning. A vendor-neutral spec format that aligns humans and AI on what to build before code is written. It works across 30+ coding agents and IDEs, which is why teams call it the most portable option here.

Workflow. Fluid and action-based: /opsx:explore → /opsx:propose → /opsx:apply → /opsx:archive. openspec init installs the slash commands into your AI tool. In the newer artifact-guided workflow, /opsx:propose drafts a proposal, specs, design, and tasks in one pass.

Spec format. Plain Markdown. specs/[capability]/spec.md holds WHAT/WHY, an optional design.md holds HOW. Proposed changes live in changes/[change]/ with proposal.md, tasks.md, and complete future-state specs. No diff syntax and no special markup to learn.

Enforcement. Light and fluid. You can update any artifact at any time; there are no phase gates. Config profiles (openspec config profile) choose the delivery method (skills, commands, or both) and which workflows to enable.

AI support. Broad: GitHub Copilot, Codex, Claude, Cursor, Atlassian Rovo Dev, MiniMax Code, plus a generic agents target (--tools agents → .agents/skills/). npm package: @fission-ai/openspec (v1.8.0 at time of writing).

Strengths. Low ceremony, portable across tools, brownfield-friendly — the changes/ layer sits neatly over an existing repo.

Trade-offs. Little enforcement. If you want the agent forced through gates, this is not it.

Target users. Teams using AI agents across multiple IDEs and CLIs that want a common spec format without buying into a methodology.

GitHub Spec Kit — opinionated SDD harness

Repo: github.com/github/spec-kit

Positioning. GitHub’s intent-driven toolkit for Spec-Driven Development (SDD). It ships a ready-to-use SDD process and is extensible through extensions, presets, and bundles.

Workflow. Structured SDD phases. specify init bootstraps the project and agent integration, then /speckit.constitution (governing principles) → /speckit.specify (what and why) → /speckit.plan (tech stack) → /speckit.tasks (task list) → /speckit.implement (execute tasks in dependency order). You can run it step by step or end to end.

Spec format. Structured spec Markdown plus tasks.md. Skills-based mode writes speckit-<name>/SKILL.md files under .github/skills/; a legacy .agent.md + .prompt.md mode exists but is deprecated.

Enforcement. Moderate. The SDD phases are opinionated, but nothing stops you from running the commands manually in any order.

AI support. --integration copilot|claude|gemini, with Copilot as the default. Extensions cover Jira (/speckit.jira.specstoissues) and Linear (/speckit.linear.sync).

Strengths. Tight GitHub/Copilot ecosystem fit, an active extension and preset system, and community bundles for role-based setups.

Trade-offs. More ceremony than OpenSpec and a heavier setup (uv plus Python 3.11+ required).

Target users. Organizations on GitHub and Copilot that want spec-led AI development with optional Jira/Linear sync.

Superpowers — skills library plugin

Repo: github.com/obra/superpowers

Positioning. Not a spec format. Superpowers is a skills-library plugin — a software development methodology built on composable skills plus initial instructions that make your agent use them. It started on Claude Code and now supports many harnesses.

Workflow. A basic dev sequence via skills: brainstorming → using-git-worktrees → writing-plans → subagent-driven-development / executing-plans → test-driven-development (RED-GREEN-REFACTOR) → requesting-code-review → finishing-a-development-branch. Skills trigger automatically; you do not type slash commands for each step.

Spec/format. Skills are Markdown SKILL.md files with frontmatter. The writing-plans skill produces bite-sized task plans (2–5 minutes each, with exact file paths and verification steps). There is no rigid spec schema.

Enforcement. Moderate. Where a skill activates, TDD is enforced and critical code-review issues block progress. But skills are composable and opt-in.

AI support. Claude Code is primary (install via plugin marketplace). OpenCode, Antigravity, Codex, Cursor, Gemini CLI, Kimi, Copilot CLI, and Pi are also supported.

Strengths. Batteries-included skills library, strong TDD discipline, and a large community.

Trade-offs. Not a portable spec format. Its workflow is tied to the agent harness you install it into.

Target users. Developers on Claude Code (or a supported harness) who want a disciplined workflow without adopting a separate spec schema.

BMAD Method — full agile methodology

Repo: github.com/bmad-code-org/bmad-method (renders as BMAD-METHOD)

Positioning. A full AI-driven agile development methodology from ideation to implementation. It is distributed as an npm package (bmad-method) that installs specialized agents and guided workflows into your dev environment.

Workflow. Four phase-gated phases, with a delivery loop that sizes itself to the work — small changes can go straight to build:

Analysis (optional): bmad-brainstorming, bmad-forge-idea, bmad-deep-recon, bmad-product-brief, bmad-prfaq (working backwards).
Planning: bmad-prd, bmad-ux, bmad-spec — distills intent into a SPEC.md contract.
Solutioning: bmad-architecture (→ ARCHITECTURE-SPINE.md), bmad-create-epics-and-stories, bmad-sprint-planning (a PASS/CONCERNS/FAIL readiness gate).
Implementation: bmad-build, bmad-code-review, bmad-correct-course, bmad-retrospective.

Spec/format. A rich artifact set: SPEC.md, prd.md, ARCHITECTURE-SPINE.md, epic files, stories.yaml, and validation reports.

Enforcement. High. Phase-locked with readiness gates and persona-based agents (for example, a strategic business analyst persona named Mary).

AI support. The npm package installs specialized agents and guided workflows; persona-based multi-agent collaboration.

Strengths. Covers the whole path from a vague idea to shipped code and keeps decisions explicit as durable context.

Trade-offs. The most process to absorb. Overkill for a small solo project.

Target users. Teams that want end-to-end, phase-gated AI-driven development on larger or complex projects.

GSD Core — context engineering with an enforced phase loop

Repo: github.com/open-gsd/gsd-core

Positioning. A meta-prompting, context-engineering, and spec-driven development framework. It sits between you and the agent and solves context degradation (context rot) by running heavy research, planning, and execution in fresh-context subagents while your main session stays lean.

Workflow. Each milestone repeats the same phase loop, one phase at a time:

Discuss — capture implementation decisions in CONTEXT.md before anything is planned.
Plan — a research gate blocks while RESEARCH.md has open questions. The Planner writes PLAN.md files, then a Plan Checker verifies them (max 3 times). Requirement and decision-coverage gates are blocking.
Execute — plans run in parallel waves; each executor starts with a clean 200k-token context and makes atomic commits; a Verifier writes VERIFICATION.md.
Verify — /gsd-verify-work produces UAT.md; an optional UI review writes UI-REVIEW.md.
Ship — create the PR, archive the phase, repeat.

Spec/format. Structured artifacts: CONTEXT.md, RESEARCH.md, PLAN.md (plans in XML format, 2–3 tasks each sized to one context window, with acceptance criteria), SUMMARY.md, VERIFICATION.md, STATE.md, UAT.md.

Enforcement. Highest of the five. Blocking research and decision-coverage gates, verification loops, package-legitimacy checks, and cross-AI reviewer lanes.

AI support. Multi-runtime and tier-1: Claude Code, Codex, Antigravity CLI, Kimi CLI, Copilot, Cursor, Windsurf, OpenCode, Kilo.

Strengths. Built for long-running projects where context degradation is the enemy; enforced verification and cross-AI review.

Trade-offs. Heavy process. The XML plan format and the gates take time to learn.

Target users. Long or complex projects, and multi-agent setups that want enforced verification.

Full comparison table

GitHub star counts below are approximate, pulled from each repo’s GitHub page on 2026-08-07. They move quickly, so re-check before you quote them.

Framework	Primary positioning	Workflow	Spec format	Enforcement	AI tool / agent support	Typical use cases	GitHub Stars*
OpenSpec	Lightweight vendor-neutral spec format	Fluid: explore → propose → apply → archive (`/opsx:*`)	Markdown specs (`spec.md` / `design.md` + `changes/`)	Light, configurable profiles	Copilot, Codex, Claude, Cursor, Rovo Dev, MiniMax, generic `agents`	Spec-first changes across multiple IDEs/CLIs	~64k
GitHub Spec Kit	Opinionated SDD harness with `specify` CLI	`specify init` → `/speckit.specify` → `/speckit.plan` → `/speckit.tasks` → `/speckit.implement`	Structured spec Markdown + `tasks.md`; skills-based or legacy prompts	Moderate, structured SDD phases	Copilot (default), Claude, Gemini; Jira/Linear extensions	Orgs on GitHub/Copilot wanting spec-led AI dev + tracker sync	~126k
Superpowers	Skills-library plugin (not a spec format)	brainstorm → worktree → writing-plans → subagent/executing-plans → TDD → code-review → finish branch	Skills (`SKILL.md`); task plans via `writing-plans`	Moderate; TDD + review gates where activated	Claude Code (primary), OpenCode, Codex, Cursor, Gemini, Copilot, and more	Batteries-included skills + disciplined workflow on your agent	~268k
BMAD Method	Full AI-driven agile methodology (idea → code)	4 phase-gated phases: Analysis → Planning → Solutioning → Implementation (`bmad-*`)	`SPEC.md` + PRD + `ARCHITECTURE-SPINE.md` + epics/stories	High; phase-locked readiness gates, persona agents	npm installs specialized agents/personas	Larger/complex projects wanting structured end-to-end AI dev	~52k
GSD Core	Context-engineering + spec-driven phase loop	discuss → plan (blocking research + coverage gates) → execute (waves + verifier) → verify (`/gsd-*`)	`CONTEXT.md`, `RESEARCH.md`, `PLAN.md` (XML plans) + `VERIFICATION.md` / `UAT.md` / `STATE.md`	Highest; blocking gates, verify loops, cross-AI review	Tier-1 multi-runtime: Claude Code, Codex, Antigravity, Kimi, Copilot, Cursor, Windsurf, OpenCode, Kilo	Long/complex projects fighting context degradation	~8k

*Approximate stars as of 2026-08-07. Superpowers leads by far in adoption, but its repo is a skills library, not a spec schema.

enforcement
   (high) │
          │   GSD Core ●     BMAD ●
          │   Spec Kit ●
          │   Superpowers ●
          │   OpenSpec ●
   (low)  │
          └─────────────────────────────────
               spec format       full methodology
                      (breadth)

Which one should you choose?

Read these as scenario → recommendation, not a ranking. Each option names the why and a caveat.

Scenario	Try first	Why	Caveat
Solo developer, small greenfield project	OpenSpec, or Superpowers on Claude Code	OpenSpec is light and portable; Superpowers adds discipline without a schema	Superpowers is harness-specific
Startup, GitHub/Copilot-centric, spec-led	GitHub Spec Kit	First-class Copilot support and Jira/Linear sync	Heavier setup (uv + Python)
Enterprise or regulated, needs gates and audit	GSD Core or BMAD Method	Enforced coverage gates, cross-AI review, phase gates	Highest process cost
Large complex product, idea → code	BMAD Method	Full analysis → solutioning → implementation lifecycle	You must follow the phases
Brownfield (existing codebase)	OpenSpec or GSD Core	OpenSpec’s `changes/` layer overlays an existing repo; GSD has an onboard mode	Spec Kit/Superpowers/BMAD are greener-field oriented, though adaptable
Greenfield from scratch	BMAD or GSD Core	Full lifecycle (BMAD) or greenfield research mode (GSD)	Both are heavy for small projects
Multi-agent / multi-tool shop	GSD Core or OpenSpec	GSD is tier-1 multi-runtime; OpenSpec is vendor-neutral	GSD adds real ceremony
Just want a disciplined dev workflow, not a spec schema	Superpowers	Composable skills, enforced TDD	Not portable across agents by default

Can you combine them?

Only combinations that are documented or widely adopted, with uncertainty called out:

OpenSpec + a coding agent’s native skills — documented. OpenSpec explicitly supports skills/commands/both delivery and a vendor-neutral agents directory.
Spec Kit + Jira/Linear — documented. The extension system ships /speckit.jira.specstoissues and /speckit.linear.sync.
BMAD bmad-spec + its own implementer — documented within BMAD. The SPEC.md contract feeds bmad-build downstream.
GSD Core cross-AI reviewer lanes — documented (for example, a Codex reviewer lane via codex exec).
Superpowers + OpenSpec skills — plausible: both write to .agents/skills/-style locations, but they are not officially documented together. Verify before relying on it.
BMAD planning phases inside GSD Core’s phase loop, or Spec Kit tasks.md driving BMAD epics — not documented. These may conflict in enforcement semantics, so treat them as untested.

If a combination is not listed above, assume it is not officially supported until you see docs or a widely adopted example.

FAQ

What is an AI specification framework vs a full project methodology? A framework is a spec format and workflow (OpenSpec, Spec Kit). A methodology is an end-to-end process from idea to code with gates (BMAD, and arguably GSD). Superpowers is neither — it is a skills layer.

Is OpenSpec a specification framework or a methodology? A framework. It gives you a Markdown spec format and slash commands, with no enforced phase gates.

Which is best for GitHub Copilot? Spec Kit, since Copilot is its default integration. OpenSpec also supports Copilot.

Which enforces the most discipline / gates? GSD Core, then BMAD. GSD has blocking research and decision-coverage gates; BMAD has phase-locked readiness gates.

Can I use Superpowers with OpenSpec or Spec Kit? Superpowers is harness-specific. Both OpenSpec and Superpowers target .agents/skills/-style locations, so co-existence is plausible, but combining them is not officially documented — verify first.

Do these work on brownfield codebases? OpenSpec and GSD Core are the best documented for existing code. The others are greener-field oriented but can be adapted.

Are GitHub star counts stable? No. They change daily. I date-stamped the numbers above as of 2026-08-07; re-verify before you quote them.

Which supports the most coding agents? GSD Core lists the widest tier-1 set (9+ runtimes), while OpenSpec advertises 30+ tools via slash commands and a vendor-neutral agents target.

Summary

In this post, I compared five AI specification frameworks for 2026 — OpenSpec, GitHub Spec Kit, Superpowers, BMAD Method, and GSD Core — across positioning, workflow, spec format, enforcement, and agent support. The key takeaway: they live at different layers (format, skills, methodology), so pick by project size, the enforcement level you want, and the coding agent you run. Read the linked repos and the decision guide before you adopt one.

Sources

All facts in this post come from those official repos and docs. Star counts and versions were checked on 2026-08-07 and may have changed since.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!