Choosing SDD Tools: OpenSpec or Spec-Kit

wzdushu@gmail.com (wanzi) — Fri, 27 Feb 2026 10:30:00 +0800

In the previous article “What is SDD,” we explored the importance of Specification-Driven Development. This article provides an in-depth comparison of two mainstream SDD tools—OpenSpec and Spec-Kit—to help developers choose the right tool for their needs.

Overview of OpenSpec and Spec-Kit

Introduction to OpenSpec

OpenSpec is a Specification-Driven Development (SDD) framework developed by Fission AI, designed specifically for AI coding assistants.

Project URL: https://github.com/Fission-AI/OpenSpec

Core Features:

Lightweight specification layer to align humans and AI before coding
Independent folder for each change, containing proposal, specification, design, and tasks
Supports 20+ AI assistants via slash command integration
Flexible iteration without rigid stage gates
Complete change lifecycle management

Introduction to Spec-Kit

Spec-Kit is an open-source Specification-Driven Development toolkit developed by GitHub.

Project URL: https://github.com/github/spec-kit

Core Features:

Transforms specification documents into executable specifications to directly generate working code
Supports multiple AI agents: Claude Code, Copilot, Gemini CLI, Codex, Cursor, Windsurf, etc.
Complete workflow: Constitution → Specify → Plan → Tasks → Implement
Rich extension ecosystem: Jira integration, Azure DevOps integration, code review, etc.
Supports both Greenfield and Brownfield projects

Installation and Configuration

OpenSpec Installation

Prerequisites: Node.js 20.19.0 or higher

# npm install
npm install -g @fission-ai/openspec@latest

# Also supports pnpm, yarn, bun, and nix
pnpm add -g @fission-ai/openspec

Initialize Project

# Initialize in project directory
openspec init

# Select workflow configuration
openspec config profile

# Refresh AI guidance
openspec update

Disable Telemetry (Optional)

1
2
3

export OPENSPEC_TELEMETRY=0
# or
export DO_NOT_TRACK=1

Spec-Kit Installation

Prerequisites: Python environment (uv recommended)

# Persistent installation (recommended)
uv tool install specify-cli --from git+https://github.com/github/spec-kit.git

# One-time use
uvx --from git+https://github.com/github/spec-kit.git specify init <PROJECT_NAME>

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

Initialize Project

# Create new project
specify init <PROJECT_NAME>

# Initialize in existing project
specify init . --ai claude

# Initialize specifying AI agent
specify init --here --ai claude

# Check environment
specify check

Core Feature Comparison

Basic Features

Feature	OpenSpec	Spec-Kit
Implementation Language	Node.js	Python
CLI Tool	openspec	specify
AI Agent Support	20+	10+
Change Structure	Proposal+Spec+Design+Tasks	Constitution+Specify+Plan+Tasks
State Management	Full Lifecycle	Phased Workflow
Extension Ecosystem	Basic	Rich (Jira, Azure DevOps, etc.)
Parallel Execution	Basic Support	Work Package Mode

OpenSpec Slash Commands

Command	Function
`/opsx:propose "idea"`	Create new proposal
`/opsx:new`	Create new change
`/opsx:continue`	Continue change
`/opsx:apply`	Execute tasks
`/opsx:ff`	Fast forward to completion
`/opsx:verify`	Verify change
`/opsx:sync`	Sync status
`/opsx:archive`	Archive completed changes
`/opsx:bulk-archive`	Bulk archive
`/opsx:onboard`	Onboard new members

Spec-Kit Slash Commands

Command	Function
`/speckit.constitution`	Establish project governance principles
`/speckit.specify`	Define functional requirements
`/speckit.plan`	Technical planning
`/speckit.tasks`	Break down tasks
`/speckit.implement`	Execute implementation
`/speckit.clarify`	Clarify ambiguous requirements
`/speckit.analyze`	Consistency analysis
`/speckit.checklist`	Quality check

Workflow Comparison

OpenSpec Workflow

OpenSpec is change-centric, with each change having an independent folder structure:

Change Folder Structure:
├── proposal.md      # Proposal description
├── spec.md          # Specification
├── design.md        # Technical design
├── tasks.md         # Task list
└── artifacts/       # Artifacts

Development Loop

1. Propose Idea
   /opsx:propose "Add user authentication"

2. Create Change
   /opsx:new
   # Creates change folder

3. Write Specification
   Edit spec.md

4. Technical Design
   Edit design.md

5. Execute Tasks
   /opsx:apply

6. Verify Completion
   /opsx:verify

7. Archive
   /opsx:archive

Spec-Kit Workflow

Spec-Kit adopts a phased workflow, emphasizing the executability of specification documents:

Workflow:
Constitution → Specify → Plan → Tasks → Implement

Development Loop

1. Initialize Project
   specify init . --ai claude

2. Establish Principles
   /speckit.constitution
   # Define project governance standards

3. Define Specification
   /speckit.specify
   # Describe the functionality to build

4. Create Plan
   /speckit.plan
   # Provide tech stack and architecture

5. Break Down Tasks
   /speckit.tasks
   # Generate executable task list

6. Execute Implementation
   /speckit.implement
   # Implement features according to plan

AI Agent Support Comparison

OpenSpec Support

Claude Code ✅
GitHub Copilot ✅
Gemini CLI ✅
And 20+ other AI assistants

Spec-Kit Support

AI Agent	Support	Notes
Claude Code	✅
GitHub Copilot	✅
Gemini CLI	✅
Codex CLI	✅	Requires `--ai-skills` parameter
Cursor	✅
Windsurf	✅
Qoder CLI	✅
Kilo Code	✅
Generic	✅	Requires specifying `--ai-commands-dir`

Spec-Kit Extension Ecosystem

Spec-Kit boasts a rich set of extensions and presets:

Extensions

Extension	Function
AI-Driven Engineering (AIDE)	7-step structured workflow
Jira Integration	Sync tasks with Jira
Azure DevOps Integration	Sync with Azure DevOps
Review Extension	Code review
Verify Extension	Specification verification
Spec Sync	Detect deviations between spec and implementation

Presets

Preset	Function
AIDE In-Place Migration	Tech migration preset
Pirate Speak	Pirate style output

Use Case Comparison

Scenarios for Choosing OpenSpec

Projects requiring complete change tracking
Teams that value the Proposal → Spec → Design → Task workflow
Environments using a mix of multiple AI tools
Projects preferring flexible iteration over strict phases
Teams requiring frequent change reviews

Scenarios for Choosing Spec-Kit

Enterprise environments requiring Jira/Azure DevOps integration
Need for code review and quality gates
Teams that value the executability of specification documents
Scenarios requiring technical migration support
Users of mainstream AI agents like Claude Code and Copilot

Summary Comparison

┌─────────────────────────────────────────────────────────┐
│                   SDD Tool Comparison                    │
├─────────────────────────────────────────────────────────┤
│                                                         │
│   OpenSpec                │         Spec-Kit             │
│   ─────────               │         ─────────             │
│   • Node.js Implementation│         • Python Implementation│
│   • Change-driven         │         • Executable Specs    │
│   • 20+ AI Assistants     │         • 10+ AI Assistants   │
│   • Flexible Iteration    │         • Phased Workflow     │
│   • Full Change Lifecycle │         • Rich Ecosystem      │
│                          │         • Enterprise Integration│
│                                                         │
│   Best For:               │         Best For:             │
│   • Change Tracking       │         • Enterprise Env      │
│   • Flexible Iteration    │         • Quality Gates       │
│   • Multi-AI Tools        │         • Spec Verification   │
│                                                         │
└─────────────────────────────────────────────────────────┘

Final Recommendations

Choose OpenSpec if:

You need a complete Proposal → Spec → Design → Task workflow
You value historical tracking and review of changes
You prefer a flexible, iterative working style
You use various AI programming tools

Choose Spec-Kit if:

You need integration with enterprise tools (Jira, Azure DevOps)
You prioritize code review and quality verification
You need consistency checks between specifications and implementation
You use mainstream AI agents like Claude Code or Copilot

Can be used together: The two tools can complement each other—use OpenSpec for rapid change exploration and Spec-Kit for enterprise-level specification management.

@Fission-Ai/Openspec on Wanzi's Blog – Notes on life, tech, and DevOps.