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

1
2
3
4
5

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

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

Initialize Project

1
2
3
4
5
6
7
8

# 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)

1
2
3
4
5
6
7
8

# 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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 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.