Skip to main content
Glama
speckitmcp
by jthom233

Overview

speckitmcp bridges GitHub's Spec-Kit toolkit with any MCP-compatible AI assistant — Claude Code, Cursor, VS Code Copilot, Windsurf, and more.

It exposes the full Spec-Driven Development (SDD) workflow as MCP tools, resources, and prompts, so your AI agent can:

  • Initialize and manage spec-kit projects

  • Author specifications, technical plans, and task breakdowns

  • Track implementation progress and mark tasks complete

  • Validate cross-artifact consistency with a 6-pass analysis engine

  • Generate quality checklists and convert tasks to GitHub issues

All without leaving your editor.


Related MCP server: Gigaspec

Quick Start

Prerequisites

Requirement

Install

Node.js 18+

nodejs.org

spec-kit CLI

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

Install & Build

git clone https://github.com/jthom233/speckitmcp.git
cd speckitmcp
npm install
npm run build

Connect to Your AI Agent

Add to ~/.claude/settings.json (global) or .claude/settings.json (project):

{
  "mcpServers": {
    "spec-kit": {
      "command": "node",
      "args": ["/absolute/path/to/speckitmcp/dist/index.js"]
    }
  }
}

Add to .cursor/mcp.json in your project root:

{
  "mcpServers": {
    "spec-kit": {
      "command": "node",
      "args": ["/absolute/path/to/speckitmcp/dist/index.js"]
    }
  }
}

Add to .vscode/mcp.json in your project root:

{
  "servers": {
    "spec-kit": {
      "command": "node",
      "args": ["/absolute/path/to/speckitmcp/dist/index.js"]
    }
  }
}

Point your client's MCP configuration at:

node /absolute/path/to/speckitmcp/dist/index.js

The server communicates over stdio using the standard MCP JSON-RPC protocol.


Tools

The server exposes 13 tools that map to every phase of the SDD workflow:

Tool

Description

speckit_init

Initialize spec-kit project structure

speckit_check

Check spec-kit installation and system prerequisites

speckit_version

Get spec-kit CLI version

speckit_status

View project status with task completion stats

speckit_constitution

Read, create, or update project constitution with optional version bumping

speckit_specify

Create feature spec with template loading, script integration, and auto-generated quality checklist

speckit_plan

Multi-phase planning (research, design, plan) with spec prerequisite and constitution gate

speckit_tasks

Generate user-story-organized task lists (requires spec.md and plan.md)

speckit_implement

Read tasks/docs, mark tasks complete with checklist gate, or add notes

speckit_clarify

Scan spec.md for ambiguities (9 categories, max 5 questions) or answer them inline

speckit_analyze

Read-only 6-pass analysis: duplication, ambiguity, underspecification, constitution alignment, coverage gaps, inconsistency

speckit_checklist

Generate requirement quality checklists (spec quality, not implementation) in checklists/ subdirectory

speckit_tasks_to_issues

Convert tasks.md to GitHub issues (dry-run by default)

Key Features

  • Script integration — Platform-aware bash/powershell helper scripts invoked automatically

  • Template loading — Loads templates from .specify/templates/ with embedded fallbacks

  • Prerequisites checking — Tools verify prior artifacts exist before proceeding

  • Constitution gate — Planning phase reads the project constitution as mandatory context

  • Checklist gate — Implementation checks for incomplete checklist items before marking tasks done

  • 6-pass analysis engine — Catches duplication, ambiguity, underspecification, constitution violations, coverage gaps, and inconsistencies

  • GitHub issue creation — Convert a tasks.md file into GitHub issues via speckit_tasks_to_issues


Resources

The server exposes spec-kit project files as read-only MCP resources:

URI

Content

speckit://constitution

Project constitution

speckit://templates/{name}

Spec-kit templates

speckit://specs/{feature}/spec

Feature specification

speckit://specs/{feature}/plan

Implementation plan

speckit://specs/{feature}/tasks

Task list

speckit://specs/{feature}/research

Research notes

speckit://specs/{feature}/data-model

Data model

speckit://specs/{feature}/quickstart

Quickstart guide

speckit://specs/{feature}/checklists/{name}

Quality checklists

speckit://specs/{feature}/contracts/{name}

API contracts


Prompts

Ten built-in prompts guide your AI agent through each SDD phase:

Prompt

Purpose

sdd_workflow

End-to-end walkthrough of the full SDD lifecycle

sdd_specify

Structured feature specification authoring

sdd_clarify

Guided ambiguity resolution

sdd_plan

Technical planning with architecture and stack decisions

sdd_tasks

Task breakdown with phasing, dependencies, and parallelism

sdd_implement

Task execution and progress tracking

sdd_checklist

Requirement quality checklist generation

sdd_analyze

Cross-artifact consistency validation

sdd_constitution

Guided creation of project principles and governance

sdd_taskstoissues

Convert tasks to GitHub issues


The SDD Workflow

  init → constitution → specify → clarify → plan → tasks → checklist → analyze → implement → tasks_to_issues
  1. Init — speckit_init — Scaffold the project with .specify/ templates

  2. Constitution — speckit_constitution — Define project principles and governance before specifying

  3. Specify — speckit_specify — Define requirements as prioritized user stories with template loading

  4. Clarify — speckit_clarify — Scan for and resolve ambiguities before committing to a plan

  5. Plan — speckit_plan — Multi-phase planning gated on project constitution

  6. Tasks — speckit_tasks — Generate user-story-organized task lists with prerequisites check

  7. Checklist — speckit_checklist — Generate requirement quality checklists

  8. Analyze — speckit_analyze — 6-pass validation of spec / plan / tasks alignment

  9. Implement — speckit_implement — Track completion with checklist gate and regex-safe marking

  10. Tasks to Issues — speckit_tasks_to_issues — Push tasks to GitHub as issues


Project Structure

src/
├── index.ts                   # Entry point — stdio transport
├── server.ts                  # MCP server — handler registration
├── cli.ts                     # spec-kit CLI wrapper (child_process)
├── tools/
│   ├── index.ts               # Tool registry
│   ├── init.ts                # speckit_init
│   ├── check.ts               # speckit_check
│   ├── version.ts             # speckit_version
│   ├── status.ts              # speckit_status
│   ├── constitution.ts        # speckit_constitution
│   ├── specify.ts             # speckit_specify
│   ├── plan.ts                # speckit_plan
│   ├── tasks.ts               # speckit_tasks
│   ├── implement.ts           # speckit_implement
│   ├── clarify.ts             # speckit_clarify
│   ├── analyze.ts             # speckit_analyze
│   ├── checklist.ts           # speckit_checklist
│   └── tasks-to-issues.ts     # speckit_tasks_to_issues
├── resources/
│   └── index.ts               # MCP resource handlers
└── prompts/
    └── index.ts               # SDD workflow prompts

Development

npm install          # Install dependencies
npm run build        # Compile TypeScript → dist/
npm run dev          # Watch mode (rebuild on change)

Manual Smoke Test

echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}' | node dist/index.js

You should see a JSON-RPC response with serverInfo.name: "spec-kit-mcp".


Tech Stack

Layer

Choice

Language

TypeScript 5 (strict mode, ESM)

Runtime

Node.js 18+

Protocol

@modelcontextprotocol/sdk v1.x

Validation

Zod

Transport

stdio (JSON-RPC 2.0)

CLI Integration

Node.js child_process wrapping specify


Contributing

Contributions are welcome! Please open an issue first to discuss what you'd like to change.

  1. Fork the repo

  2. Create a feature branch (git checkout -b feat/my-feature)

  3. Commit your changes

  4. Push to your fork and open a Pull Request


License

MIT

Available Tools

13 tools
speckit_analyzeA

Analyze cross-artifact consistency for a feature across 6 passes: Duplication, Ambiguity, Underspecification, Constitution Alignment, Coverage Gaps, and Inconsistency. Strictly read-only — never writes files.

Inputs: feature_name (required), project_path.

speckit_checkA

Check that spec-kit and all required tools are installed. Returns version and system information.

Inputs: no named parameters.

speckit_checklistA

Create a requirement quality checklist for a feature. Generates checklists that assess spec quality (completeness, clarity, coverage, consistency) — not implementation status. Saved to specs/{feature}/checklists/{name}.md.

Inputs: feature_name (required), content, project_path, checklist_name, +1 more.

speckit_clarifyA

Manage clarification questions for a feature. Scan spec.md for ambiguities across 9 taxonomy categories and return up to 5 prioritized questions (scan), or write an answer inline in spec.md (answer). Does not write clarifications.md.

Inputs: action (required), feature_name (required), answer, project_path, +1 more.

speckit_constitutionA

Read, create, or update the project constitution. The constitution defines core principles, technology choices, quality standards, and governance rules for the project.

Inputs: action, content, placeholders, project_path, +1 more.

speckit_implementB

Track implementation progress for a feature. Read current tasks and related docs, mark tasks complete (with optional checklist gate), or add implementation notes.

Inputs: feature_name (required), force, notes, action, +2 more.

speckit_initA

Initialize a new spec-kit project. Creates .specify/ directory with templates, constitution, and agent command files. Automatically confirms if the directory is non-empty.

Inputs: ai_agent, script_type, project_name, project_path.

speckit_planA

Create or update a technical implementation plan. Creates specs/{feature}/plan.md with architecture, tech stack, and implementation approach. Also supports writing research and design artifacts.

Inputs: feature_name (required), phase, content, contracts, +5 more.

speckit_specifyA

Create or update a feature specification. Creates specs/{feature}/spec.md with requirements, user stories, and acceptance criteria.

Inputs: content, description, feature_name, project_path.

speckit_statusA

Get the status of a spec-kit project. Shows which specs, plans, tasks, checklists, research, data-model, quickstart, and contracts exist.

Inputs: project_path.

speckit_tasksB

Create or update a task breakdown. Creates specs/{feature}/tasks.md with phased, actionable tasks with dependencies and parallel opportunities.

Inputs: feature_name (required), content, project_path.

speckit_tasks_to_issuesA

Convert spec-kit tasks to GitHub issues. Reads tasks.md and creates corresponding GitHub issues.

Inputs: feature_name (required), labels, dry_run, project_path.

speckit_versionA

Get version information for both the MCP server and the spec-kit CLI.

Inputs: no named parameters.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 13 tools

    Disambiguation3/5

    Several tools have overlapping purposes or similar names: speckit_check, speckit_status, and speckit_checklist could be confused, and speckit_clarify and speckit_analyze both address ambiguity. Descriptions differentiate them, but the boundaries are not instantly clear.

    Naming Consistency3/5

    All tools share the speckit_ prefix, but the suffixes mix verbs (init, check, specify, implement, clarify, analyze) and nouns (version, status, constitution, tasks, checklist) without a consistent verb_noun pattern. The compound tasks_to_issues also breaks the pattern.

    Tool Count5/5

    At 13 tools, the server covers setup, project status, spec/plan/task creation, implementation tracking, quality analysis, and GitHub integration without feeling bloated. Each tool serves a distinct phase of the spec-kit workflow.

    Completeness4/5

    The toolset covers the full spec-kit lifecycle: init, check, version, status, constitution, spec, plan, tasks, implement, clarify, analyze, checklist, and GitHub issue conversion. Minor gaps include no explicit read/delete operations for artifacts, but these are not critical for the workflow.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables spec-driven development workflows with AI assistants, providing tools for managing specification lifecycles, task dependencies, code navigation, testing, and automated reviews through a unified CLI and MCP interface.
      4
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      An AI-native specification framework that enables deep requirements analysis and structured project planning through intelligent Q\&A workflows. The MCP server provides tools for project initialization, requirement analysis, and the generation of living documentation like development plans and architecture specs.
      1 npm
      Apache 2.0
    • A
      license
      Not graded
      quality
      C
      maintenance
      Centralized MCP server for spec-driven AI agent workflows, enabling isolated feature management, task tracking, and implementation with handoff and archiving capabilities across multiple projects and developers.
      27 npm
      1
      MIT