speckitmcp
Integrates with GitHub's Spec-Kit to provide a full Spec-Driven Development workflow, enabling specification authoring, planning, task management, analysis, and conversion of tasks to GitHub issues.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@speckitmcp Create a feature spec for login"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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+ | |
spec-kit CLI |
|
Install & Build
git clone https://github.com/jthom233/speckitmcp.git
cd speckitmcp
npm install
npm run buildConnect 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.jsThe 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 |
| Initialize spec-kit project structure |
| Check spec-kit installation and system prerequisites |
| Get spec-kit CLI version |
| View project status with task completion stats |
| Read, create, or update project constitution with optional version bumping |
| Create feature spec with template loading, script integration, and auto-generated quality checklist |
| Multi-phase planning (research, design, plan) with spec prerequisite and constitution gate |
| Generate user-story-organized task lists (requires spec.md and plan.md) |
| Read tasks/docs, mark tasks complete with checklist gate, or add notes |
| Scan spec.md for ambiguities (9 categories, max 5 questions) or answer them inline |
| Read-only 6-pass analysis: duplication, ambiguity, underspecification, constitution alignment, coverage gaps, inconsistency |
| Generate requirement quality checklists (spec quality, not implementation) in checklists/ subdirectory |
| 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 fallbacksPrerequisites 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 |
| Project constitution |
| Spec-kit templates |
| Feature specification |
| Implementation plan |
| Task list |
| Research notes |
| Data model |
| Quickstart guide |
| Quality checklists |
| API contracts |
Prompts
Ten built-in prompts guide your AI agent through each SDD phase:
Prompt | Purpose |
| End-to-end walkthrough of the full SDD lifecycle |
| Structured feature specification authoring |
| Guided ambiguity resolution |
| Technical planning with architecture and stack decisions |
| Task breakdown with phasing, dependencies, and parallelism |
| Task execution and progress tracking |
| Requirement quality checklist generation |
| Cross-artifact consistency validation |
| Guided creation of project principles and governance |
| Convert tasks to GitHub issues |
The SDD Workflow
init → constitution → specify → clarify → plan → tasks → checklist → analyze → implement → tasks_to_issuesInit —
speckit_init— Scaffold the project with.specify/templatesConstitution —
speckit_constitution— Define project principles and governance before specifyingSpecify —
speckit_specify— Define requirements as prioritized user stories with template loadingClarify —
speckit_clarify— Scan for and resolve ambiguities before committing to a planPlan —
speckit_plan— Multi-phase planning gated on project constitutionTasks —
speckit_tasks— Generate user-story-organized task lists with prerequisites checkChecklist —
speckit_checklist— Generate requirement quality checklistsAnalyze —
speckit_analyze— 6-pass validation of spec / plan / tasks alignmentImplement —
speckit_implement— Track completion with checklist gate and regex-safe markingTasks 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 promptsDevelopment
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.jsYou 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 | |
Validation | |
Transport | stdio (JSON-RPC 2.0) |
CLI Integration | Node.js |
Contributing
Contributions are welcome! Please open an issue first to discuss what you'd like to change.
Fork the repo
Create a feature branch (
git checkout -b feat/my-feature)Commit your changes
Push to your fork and open a Pull Request
License
Available Tools
13 toolsspeckit_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
Scored across 13 tools
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.
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.
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.
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
Related MCP Connectors
Spec-driven development for AI coding agents: live requirements, stories and traceability over MCP
Hosted MCP server and Agent Skills for specs, engineering threads, and project memory.
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables 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.4MIT
- AlicenseNot gradedqualityDmaintenanceAn 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 npmApache 2.0
- AlicenseNot gradedqualityDmaintenanceMCP server that equips AI agents with dev workflow tools including GitHub project management, conventional commits, visual regression testing, Jira/Confluence integration, and a persistent memory knowledge graph.11 npmMIT
- AlicenseNot gradedqualityCmaintenanceCentralized 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 npm1MIT