Copy the command below to clone the repository to your machine.
An open source toolkit that allows you to focus on product scenarios and predictable outcomes instead of vibe coding every piece from scratch.
Spec-Driven Development flips the script on traditional software development. For decades, code has been king — specifications were just scaffolding we built and discarded once the "real work" of coding began. Spec-Driven Development changes this: specifications become executable, directly generating working implementations rather than just guiding them.
Choose your preferred installation method:
Important: The only official, maintained packages for Spec Kit are published from this GitHub repository. Any packages with the same name on PyPI are not affiliated with this project and are not maintained by the Spec Kit maintainers. Always install directly from GitHub as shown below.
Install once and use everywhere. Pin a specific release tag for stability (check Releases for the latest):
# Install a specific stable release (recommended — replace vX.Y.Z with the latest tag)
uv tool install specify-cli --from git+https://github.com/github/[email protected]
# Or install latest from main (may include unreleased changes)
uv tool install specify-cli --from git+https://github.com/github/spec-kit.git
Then verify the correct version is installed:
specify version
And use the tool directly:
# Create new project
specify init <PROJECT_NAME>
# Or initialize in existing project
specify init . --ai claude
# or
specify init --here --ai claude
# Check installed tools
specify check
To upgrade Specify, see the Upgrade Guide for detailed instructions. Quick upgrade:
uv tool install specify-cli --force --from git+https://github.com/github/[email protected]
Run directly without installing:
# Create new project (pinned to a stable release — replace vX.Y.Z with the latest tag)
uvx --from git+https://github.com/github/[email protected] specify init <PROJECT_NAME>
# Or initialize in existing project
uvx --from git+https://github.com/github/[email protected] specify init . --ai claude
# or
uvx --from git+https://github.com/github/[email protected] specify init --here --ai claude
Benefits of persistent installation:
uv tool list, uv tool upgrade, uv tool uninstallIf your environment blocks access to PyPI or GitHub, see the Enterprise / Air-Gapped Installation guide for step-by-step instructions on using pip download to create portable, OS-specific wheel bundles on a connected machine.
Launch your AI assistant in the project directory. Most agents expose spec-kit as /speckit.* slash commands; Codex CLI in skills mode uses $speckit-* instead.
Use the /speckit.constitution command to create your project's governing principles and development guidelines that will guide all subsequent development.
/speckit.constitution Create principles focused on code quality, testing standards, user experience consistency, and performance requirements
Use the /speckit.specify command to describe what you want to build. Focus on the what and why, not the tech stack.
/speckit.specify Build an application that can help me organize my photos in separate photo albums. Albums are grouped by date and can be re-organized by dragging and dropping on the main page. Albums are never in other nested albums. Within each album, photos are previewed in a tile-like interface.
Use the /speckit.plan command to provide your tech stack and architecture choices.
/speckit.plan The application uses Vite with minimal number of libraries. Use vanilla HTML, CSS, and JavaScript as much as possible. Images are not uploaded anywhere and metadata is stored in a local SQLite database.
Use /speckit.tasks to create an actionable task list from your implementation plan.
/speckit.tasks
Use /speckit.implement to execute all tasks and build your feature according to the plan.
/speckit.implement
For detailed step-by-step instructions, see our comprehensive guide.
Want to see Spec Kit in action? Watch our video overview!
[!NOTE]
Community extensions are independently created and maintained by their respective authors. GitHub and the Spec Kit maintainers may review pull requests that add entries to the community catalog for formatting, catalog structure, or policy compliance, but they do not review, audit, endorse, or support the extension code itself. The Community Extensions website is also a third-party resource. Review extension source code before installation and use at your own discretion.
🔍 Browse and search community extensions on the Community Extensions website.
The following community-contributed extensions are available in catalog.community.json:
Categories:
docs — reads, validates, or generates spec artifactscode — reviews, validates, or modifies source codeprocess — orchestrates workflow across phasesintegration — syncs with external platformsvisibility — reports on project health or progressEffect:
Read-only — produces reports without modifying filesRead+Write — modifies files, creates artifacts, or updates specs| Extension | Purpose | Category | Effect | URL |
|---|---|---|---|---|
| Agent Assign | Assign specialized Claude Code agents to spec-kit tasks for targeted execution | process |
Read+Write | spec-kit-agent-assign |
| AI-Driven Engineering (AIDE) | A structured 7-step workflow for building new projects from scratch with AI assistants — from vision through implementation | process |
Read+Write | aide |
| Architect Impact Previewer | Predicts architectural impact, complexity, and risks of proposed changes before implementation. | visibility |
Read-only | spec-kit-architect-preview |
| Archive Extension | Archive merged features into main project memory. | docs |
Read+Write | spec-kit-archive |
| Azure DevOps Integration | Sync user stories and tasks to Azure DevOps work items using OAuth authentication | integration |
Read+Write | spec-kit-azure-devops |
| Branch Convention | Configurable branch and folder naming conventions for /specify with presets and custom patterns | process |
Read+Write | spec-kit-branch-convention |
| Brownfield Bootstrap | Bootstrap spec-kit for existing codebases — auto-discover architecture and adopt SDD incrementally | process |
Read+Write | spec-kit-brownfield |
| Bugfix Workflow | Structured bugfix workflow — capture bugs, trace to spec artifacts, and patch specs surgically | process |
Read+Write | spec-kit-bugfix |
| Canon | Adds canon-driven (baseline-driven) workflows: spec-first, code-first, spec-drift. Requires Canon Core preset installation. | process |
Read+Write | spec-kit-canon |
| CI Guard | Spec compliance gates for CI/CD — verify specs exist, check drift, and block merges on gaps | process |
Read-only | spec-kit-ci-guard |
| Checkpoint Extension | Commit the changes made during the middle of the implementation, so you don't end up with just one very large commit at the end | code |
Read+Write | spec-kit-checkpoint |
| Cleanup Extension | Post-implementation quality gate that reviews changes, fixes small issues (scout rule), creates tasks for medium issues, and generates analysis for large issues | code |
Read+Write | spec-kit-cleanup |
| Conduct Extension | Orchestrates spec-kit phases via sub-agent delegation to reduce context pollution. | process |
Read+Write | spec-kit-conduct-ext |
| Confluence Extension | Create a doc in Confluence summarizing the specifications and planning files | integration |
Read+Write | spec-kit-confluence |
| DocGuard — CDD Enforcement | Canonical-Driven Development enforcement. Validates, scores, and traces project documentation with automated checks, AI-driven workflows, and spec-kit hooks. Zero NPM runtime dependencies. | docs |
Read+Write | spec-kit-docguard |
| Extensify | Create and validate extensions and extension catalogs | process |
Read+Write | extensify |
| Fix Findings | Automated analyze-fix-reanalyze loop that resolves spec findings until clean | code |
Read+Write | spec-kit-fix-findings |
| FixIt Extension | Spec-aware bug fixing — maps bugs to spec artifacts, proposes a plan, applies minimal changes | code |
Read+Write | spec-kit-fixit |
| Fleet Orchestrator | Orchestrate a full feature lifecycle with human-in-the-loop gates across all SpecKit phases | process |
Read+Write | spec-kit-fleet |
| GitHub Issues Integration | Generate spec artifacts from GitHub Issues - import issues, sync updates, and maintain bidirectional traceability | integration |
Read+Write | spec-kit-github-issues |
| Iterate | Iterate on spec documents with a two-phase define-and-apply workflow — refine specs mid-implementation and go straight back to building | docs |
Read+Write | spec-kit-iterate |
| Jira Integration | Create Jira Epics, Stories, and Issues from spec-kit specifications and task breakdowns with configurable hierarchy and custom field support | integration |
Read+Write | spec-kit-jira |
| Learning Extension | Generate educational guides from implementations and enhance clarifications with mentoring context | docs |
Read+Write | spec-kit-learn |
| MAQA — Multi-Agent & Quality Assurance | Coordinator → feature → QA agent workflow with parallel worktree-based implementation. Language-agnostic. Auto-detects installed board plugins. Optional CI gate. | process |
Read+Write | spec-kit-maqa-ext |
| MAQA Azure DevOps Integration | Azure DevOps Boards integration for MAQA — syncs User Stories and Task children as features progress | integration |
Read+Write | spec-kit-maqa-azure-devops |
| MAQA CI/CD Gate | Auto-detects GitHub Actions, CircleCI, GitLab CI, and Bitbucket Pipelines. Blocks QA handoff until pipeline is green. | process |
Read+Write | spec-kit-maqa-ci |
| MAQA GitHub Projects Integration | GitHub Projects v2 integration for MAQA — syncs draft issues and Status columns as features progress | integration |
Read+Write | spec-kit-maqa-github-projects |
| MAQA Jira Integration | Jira integration for MAQA — syncs Stories and Subtasks as features progress through the board | integration |
Read+Write | spec-kit-maqa-jira |
| MAQA Linear Integration | Linear integration for MAQA — syncs issues and sub-issues across workflow states as features progress | integration |
Read+Write | spec-kit-maqa-linear |
| MAQA Trello Integration | Trello board integration for MAQA — populates board from specs, moves cards, real-time checklist ticking | integration |
Read+Write | spec-kit-maqa-trello |
| MemoryLint | Agent memory governance tool: Automatically audits and fixes boundary conflicts between AGENTS.md and the constitution. | process |
Read+Write | memorylint |
| Onboard | Contextual onboarding and progressive growth for developers new to spec-kit projects. Explains specs, maps dependencies, validates understanding, and guides the next step | process |
Read+Write | spec-kit-onboard |
| Optimize | Audit and optimize AI governance for context efficiency — token budgets, rule health, interpretability, compression, coherence, and echo detection | process |
Read+Write | spec-kit-optimize |
| Plan Review Gate | Require spec.md and plan.md to be merged via MR/PR before allowing task generation | process |
Read-only | spec-kit-plan-review-gate |
| PR Bridge | Auto-generate pull request descriptions, checklists, and summaries from spec artifacts | process |
Read-only | spec-kit-pr-bridge- |
| Presetify | Create and validate presets and preset catalogs | process |
Read+Write | presetify |
| Product Forge | Full product lifecycle: research → product spec → SpecKit → implement → verify → test | process |
Read+Write | speckit-product-forge |
| Project Health Check | Diagnose a Spec Kit project and report health issues across structure, agents, features, scripts, extensions, and git | visibility |
Read-only | spec-kit-doctor |
| Project Status | Show current SDD workflow progress — active feature, artifact status, task completion, workflow phase, and extensions summary | visibility |
Read-only | spec-kit-status |
| QA Testing Extension | Systematic QA testing with browser-driven or CLI-based validation of acceptance criteria from spec | code |
Read-only | spec-kit-qa |
| Ralph Loop | Autonomous implementation loop using AI agent CLI | code |
Read+Write | spec-kit-ralph |
| Reconcile Extension | Reconcile implementation drift by surgically updating feature artifacts. | docs |
Read+Write | spec-kit-reconcile |
| Repository Index | Generate index for existing repo for overview, architecture and module level. | docs |
Read-only | spec-kit-repoindex |
| Retro Extension | Sprint retrospective analysis with metrics, spec accuracy assessment, and improvement suggestions | process |
Read+Write | spec-kit-retro |
| Retrospective Extension | Post-implementation retrospective with spec adherence scoring, drift analysis, and human-gated spec updates | docs |
Read+Write | spec-kit-retrospective |
| Review Extension | Post-implementation comprehensive code review with specialized agents for code quality, comments, tests, error handling, type design, and simplification | code |
Read-only | spec-kit-review |
| SDD Utilities | Resume interrupted workflows, validate project health, and verify spec-to-task traceability | process |
Read+Write | speckit-utils |
| Security Review | Comprehensive security audit of codebases using AI-powered DevSecOps analysis | code |
Read-only | spec-kit-security-review |
| SFSpeckit | Enterprise Salesforce SDLC with 18 commands for the full SDD lifecycle. | process |
Read+Write | spec-kit-sf |
| Ship Release Extension | Automates release pipeline: pre-flight checks, branch sync, changelog generation, CI verification, and PR creation | process |
Read+Write | spec-kit-ship |
| Spec Critique Extension | Dual-lens critical review of spec and plan from product strategy and engineering risk perspectives | docs |
Read-only | spec-kit-critique |
| Spec Diagram | Auto-generate Mermaid diagrams of SDD workflow state, feature progress, and task dependencies | visibility |
Read-only | spec-kit-diagram- |
| Spec Refine | Update specs in-place, propagate changes to plan and tasks, and diff impact across artifacts | process |
Read+Write | spec-kit-refine |
| Spec Sync | Detect and resolve drift between specs and implementation. AI-assisted resolution with human approval | docs |
Read+Write | spec-kit-sync |
| SpecTest | Auto-generate test scaffolds from spec criteria, map coverage, and find untested requirements | code |
Read+Write | spec-kit-spectest |
| Staff Review Extension | Staff-engineer-level code review that validates implementation against spec, checks security, performance, and test coverage | code |
Read-only | spec-kit-staff-review |
| Status Report | Project status, feature progress, and next-action recommendations for spec-driven workflows | visibility |
Read-only | Open-Agent-Tools/spec-kit-status |
| Superpowers Bridge | Orchestrates obra/superpowers skills within the spec-kit SDD workflow across the full lifecycle (clarification, TDD, review, verification, critique, debugging, branch completion) | process |
Read+Write | superpowers-bridge |
| TinySpec | Lightweight single-file workflow for small tasks — skip the heavy multi-step SDD process | process |
Read+Write | spec-kit-tinyspec |
| V-Model Extension Pack | Enforces V-Model paired generation of development specs and test specs with full traceability | docs |
Read+Write | spec-kit-v-model |
| Verify Extension | Post-implementation quality gate that validates implemented code against specification artifacts | code |
Read-only | spec-kit-verify |
| Verify Tasks Extension | Detect phantom completions: tasks marked [X] in tasks.md with no real implementation | code |
Read-only | spec-kit-verify-tasks |
| What-if Analysis | Preview the downstream impact (complexity, effort, tasks, risks) of requirement changes before committing to them | visibility |
Read-only | spec-kit-whatif |
| Worktree Isolation | Spawn isolated git worktrees for parallel feature development without checkout switching | process |
Read+Write | spec-kit-worktree |
| Worktrees | Default-on worktree isolation for parallel agents — sibling or nested layout | process |
Read+Write | spec-kit-worktree-parallel |
To submit your own extension, see the Extension Publishing Guide.
[!NOTE]
Community presets are independently created and maintained by their respective authors. GitHub and the Spec Kit maintainers may review pull requests that add entries to the community catalog for formatting, catalog structure, or policy compliance, but they do not review, audit, endorse, or support the preset code itself. Review preset source code before installation and use at your own discretion.
The following community-contributed presets customize how Spec Kit behaves — overriding templates, commands, and terminology without changing any tooling. Presets are available in catalog.community.json:
| Preset | Purpose | Provides | Requires | URL |
|---|---|---|---|---|
| AIDE In-Place Migration | Adapts the AIDE extension workflow for in-place technology migrations (X → Y pattern) — adds migration objectives, verification gates, knowledge documents, and behavioral equivalence criteria | 2 templates, 8 commands | AIDE extension | spec-kit-presets |
| Canon Core | Adapts original Spec Kit workflow to work together with Canon extension | 2 templates, 8 commands | — | spec-kit-canon |
| Explicit Task Dependencies | Adds explicit (depends on T###) dependency declarations and an Execution Wave DAG to tasks.md for parallel scheduling |
1 template, 1 command | — | spec-kit-preset-explicit-task-dependencies |
| Fiction Book Writing | It adapts the Spec-Driven Development workflow for storytelling: features become story elements, specs become story briefs, plans become story structures, and tasks become scene-by-scene writing tasks. Supports single and multi-POV, all major plot structure frameworks, and two style modes, author voice sample or humanized AI prose. | 21 templates, 17 commands | — | spec-kit-preset-fiction-book-writing |
| Multi-Repo Branching | Coordinates feature branch creation across multiple git repositories (independent repos and submodules) during plan and tasks phases | 2 commands | — | spec-kit-preset-multi-repo-branching |
| Pirate Speak (Full) | Transforms all Spec Kit output into pirate speak — specs become "Voyage Manifests", plans become "Battle Plans", tasks become "Crew Assignments" | 6 templates, 9 commands | — | spec-kit-presets |
| Table of Contents Navigation | Adds a navigable Table of Contents to generated spec.md, plan.md, and tasks.md documents | 3 templates, 3 commands | — | spec-kit-preset-toc-navigation |
| VS Code Ask Questions | Enhances the clarify command to use vscode/askQuestions for batched interactive questioning. |
1 command | — | spec-kit-presets |
To build and publish your own preset, see the Presets Publishing Guide.
[!NOTE]
Community walkthroughs are independently created and maintained by their respective authors. They are not reviewed, nor endorsed, nor supported by GitHub. Review their content before following along and use at your own discretion.
See Spec-Driven Development in action across different scenarios with these community-contributed walkthroughs:
Greenfield .NET CLI tool — Builds a Timezone Utility as a .NET single-binary CLI tool from a blank directory, covering the full spec-kit workflow: constitution, specify, plan, tasks, and multi-pass implement using GitHub Copilot agents.
Greenfield Spring Boot + React platform — Builds an LLM performance analytics platform (REST API, graphs, iteration tracking) from scratch using Spring Boot, embedded React, PostgreSQL, and Docker Compose, with a clarify step and a cross-artifact consistency analysis pass included.
Brownfield ASP.NET CMS extension — Extends an existing open-source .NET CMS (CarrotCakeCMS-Core, ~307,000 lines of C#, Razor, SQL, JavaScript, and config files) with two new features — cross-platform Docker Compose infrastructure and a token-authenticated headless REST API — demonstrating how spec-kit fits into existing codebases without prior specs or a constitution.
Brownfield Java runtime extension — Extends an existing open-source Jakarta EE runtime (Piranha, ~420,000 lines of Java, XML, JSP, HTML, and config files across 180 Maven modules) with a password-protected Server Admin Console, demonstrating spec-kit on a large multi-module Java project with no prior specs or constitution.
Brownfield Go / React dashboard demo — Demonstrates spec-kit driven entirely from the terminal using GitHub Copilot CLI. Extends NASA's open-source Hermes ground support system (Go) with a lightweight React-based web telemetry dashboard, showing that the full constitution → specify → plan → tasks → implement workflow works from the terminal.
Greenfield Spring Boot MVC with a custom preset — Builds a Spring Boot MVC application from scratch using a custom pirate-speak preset, demonstrating how presets can reshape the entire spec-kit experience: specifications become "Voyage Manifests," plans become "Battle Plans," and tasks become "Crew Assignments" — all generated in full pirate vernacular without changing any tooling.
Greenfield Spring Boot + React with a custom extension — Walks through the AIDE extension, a community extension that adds an alternative spec-driven workflow to spec-kit with high-level specs (vision) and low-level specs (work items) organized in a 7-step iterative lifecycle: vision → roadmap → progress tracking → work queue → work items → execution → feedback loops. Uses a family trading platform (Spring Boot 4, React 19, PostgreSQL, Docker Compose) as the scenario to illustrate how the extension mechanism lets you plug in a different style of spec-driven development without changing any core tooling — truly utilizing the "Kit" in Spec Kit.
[!NOTE]
Community projects listed here are independently created and maintained by their respective authors. They are not reviewed, nor endorsed, nor supported by GitHub. Review their source code before installation and use at your own discretion.
Community projects that extend, visualize, or build on Spec Kit:
cc-spex - A Claude Code plugin that adds composable traits on top of Spec Kit with Superpowers-based quality gates, spec/code review, git worktree isolation, and parallel implementation via agent teams.
Spec Kit Assistant — A VS Code extension that provides a visual orchestrator for the full SDD workflow (constitution → specification → planning → tasks → implementation) with phase status visualization, an interactive task checklist, DAG visualization, and support for Claude, Gemini, GitHub Copilot, and OpenAI backends. Requires the specify CLI in your PATH.
SpecKit Companion — A VS Code extension that brings a visual GUI to Spec Kit. Browse specs in a rich markdown viewer with clickable file references, create specifications with image attachments, comment and refine each step inline (GitHub-style review), track your progress through the SDD workflow with a visual phase stepper, and manage steering documents like constitutions and templates.
| Agent | Support | Notes |
|---|---|---|
| Qoder CLI | ✅ | |
| Kiro CLI | ✅ | Use --ai kiro-cli (alias: --ai kiro) |
| Amp | ✅ | |
| Auggie CLI | ✅ | |
| Claude Code | ✅ | Installs skills in .claude/skills; invoke spec-kit as /speckit-constitution, /speckit-plan, etc. |
| CodeBuddy CLI | ✅ | |
| Codex CLI | ✅ | Requires --ai-skills. Codex recommends skills and treats custom prompts as deprecated. Spec-kit installs Codex skills into .agents/skills and invokes them as $speckit-<command>. |
| Cursor | ✅ | |
| Forge | ✅ | CLI tool: forge |
| Gemini CLI | ✅ | |
| Goose | ✅ | Uses YAML recipe format in .goose/recipes/ with slash command support |
| GitHub Copilot | ✅ | |
| IBM Bob | ✅ | IDE-based agent with slash command support |
| Jules | ✅ | |
| Kilo Code | ✅ | |
| opencode | ✅ | |
| Pi Coding Agent | ✅ | Pi doesn't have MCP support out of the box, so taskstoissues won't work as intended. MCP support can be added via extensions |
| Qwen Code | ✅ | |
| Roo Code | ✅ | |
| SHAI (OVHcloud) | ✅ | |
| Tabnine CLI | ✅ | |
| Mistral Vibe | ✅ | |
| Kimi Code | ✅ | |
| iFlow CLI | ✅ | |
| Windsurf | ✅ | |
| Junie | ✅ | |
| Antigravity (agy) | ✅ | Requires --ai-skills |
| Trae | ✅ | |
| Generic | ✅ | Bring your own agent — use --ai generic --ai-commands-dir <path> for unsupported agents |
After running specify init, your AI coding agent will have access to these slash commands for structured development. If you pass --ai <agent> --ai-skills, Spec Kit installs agent skills instead of slash-command prompt files; --ai-skills requires --ai.
Essential commands for the Spec-Driven Development workflow:
| Command | Agent Skill | Description |
|---|---|---|
/speckit.constitution |
speckit-constitution |
Create or update project governing principles and development guidelines |
/speckit.specify |
speckit-specify |
Define what you want to build (requirements and user stories) |
/speckit.plan |
speckit-plan |
Create technical implementation plans with your chosen tech stack |
/speckit.tasks |
speckit-tasks |
Generate actionable task lists for implementation |
/speckit.taskstoissues |
speckit-taskstoissues |
Convert generated task lists into GitHub issues for tracking and execution |
/speckit.implement |
speckit-implement |
Execute all tasks to build the feature according to the plan |
Additional commands for enhanced quality and validation:
| Command | Agent Skill | Description |
|---|---|---|
/speckit.clarify |
speckit-clarify |
Clarify underspecified areas (recommended before /speckit.plan; formerly /quizme) |
/speckit.analyze |
speckit-analyze |
Cross-artifact consistency & coverage analysis (run after /speckit.tasks, before /speckit.implement) |
/speckit.checklist |
speckit-checklist |
Generate custom quality checklists that validate requirements completeness, clarity, and consistency (like "unit tests for English") |
The specify tool is invoked as
specify <COMMAND> [SUBCOMMAND] [OPTIONS]
and supports the following commands:
| Command | Description |
|---|---|
init |
Initialize a new Specify project from the latest template. |
check |
Check for installed tools: git plus all CLI-based agents configured in AGENT_CONFIG (for example: claude, gemini, code/code-insiders, cursor-agent, windsurf, junie, qwen, opencode, codex, kiro-cli, shai, qodercli, vibe, kimi, iflow, pi, forge, etc.) |
version |
Show the currently installed Spec Kit version. |
extension |
Manage extensions |
preset |
Manage presets |
integration |
Manage integrations |
specify init Arguments & Optionsspecify init [PROJECT_NAME] <OPTIONS>
| Argument/Option | Type | Description |
|---|---|---|
<PROJECT_NAME> |
Argument | Name for your new project directory (optional if using --here, or use . for current directory) |
--ai |
Option | AI assistant to use (see AGENT_CONFIG for the full, up-to-date list). Common options include: claude, gemini, copilot, cursor-agent, qwen, opencode, codex, windsurf, junie, kilocode, auggie, roo, codebuddy, amp, shai, kiro-cli (kiro alias), agy, bob, qodercli, vibe, kimi, iflow, pi, forge, or generic (requires --ai-commands-dir) |
--ai-commands-dir |
Option | Directory for agent command files (required with --ai generic, e.g. .myagent/commands/) |
--script |
Option | Script variant to use: sh (bash/zsh) or ps (PowerShell) |
--ignore-agent-tools |
Flag | Skip checks for AI agent tools like Claude Code |
--no-git |
Flag | Skip git repository initialization |
--here |
Flag | Initialize project in the current directory instead of creating a new one |
--force |
Flag | Force merge/overwrite when initializing in current directory (skip confirmation) |
--skip-tls |
Flag | Skip SSL/TLS verification (not recommended) |
--debug |
Flag | Enable detailed debug output for troubleshooting |
--github-token |
Option | GitHub token for API requests (or set GH_TOKEN/GITHUB_TOKEN env variable) |
--ai-skills |
Flag | Install Prompt.MD templates as agent skills in agent-specific skills/ directory (requires --ai). Extension commands are also auto-registered as skills when extensions are added later. |
--branch-numbering |
Option | Branch numbering strategy: sequential (default — 001, 002, 003, …, 1000, … — expands beyond 3 digits automatically) or timestamp (YYYYMMDD-HHMMSS). Timestamp mode is useful for distributed teams to avoid numbering conflicts |
# Basic project initialization
specify init my-project
# Initialize with specific AI assistant
specify init my-project --ai claude
# Initialize with Cursor support
specify init my-project --ai cursor-agent
# Initialize with Qoder support
specify init my-project --ai qodercli
# Initialize with Windsurf support
specify init my-project --ai windsurf
# Initialize with Kiro CLI support
specify init my-project --ai kiro-cli
# Initialize with Amp support
specify init my-project --ai amp
# Initialize with SHAI support
specify init my-project --ai shai
# Initialize with Mistral Vibe support
specify init my-project --ai vibe
# Initialize with IBM Bob support
specify init my-project --ai bob
# Initialize with Pi Coding Agent support
specify init my-project --ai pi
# Initialize with Codex CLI support
specify init my-project --ai codex --ai-skills
# Initialize with Antigravity support
specify init my-project --ai agy --ai-skills
# Initialize with Forge support
specify init my-project --ai forge
# Initialize with an unsupported agent (generic / bring your own agent)
specify init my-project --ai generic --ai-commands-dir .myagent/commands/
# Initialize with PowerShell scripts (Windows/cross-platform)
specify init my-project --ai copilot --script ps
# Initialize in current directory
specify init . --ai copilot
# or use the --here flag
specify init --here --ai copilot
# Force merge into current (non-empty) directory without confirmation
specify init . --force --ai copilot
# or
specify init --here --force --ai copilot
# Skip git initialization
specify init my-project --ai gemini --no-git
# Enable debug output for troubleshooting
specify init my-project --ai claude --debug
# Use GitHub token for API requests (helpful for corporate environments)
specify init my-project --ai claude --github-token ghp_your_token_here
# Claude Code installs skills with the project by default
specify init my-project --ai claude
# Initialize in current directory with agent skills
specify init --here --ai gemini --ai-skills
# Use timestamp-based branch numbering (useful for distributed teams)
specify init my-project --ai claude --branch-numbering timestamp
# Check system requirements
specify check
| Variable | Description |
|---|---|
SPECIFY_FEATURE |
Override feature detection for non-Git repositories. Set to the feature directory name (e.g., 001-photo-albums) to work on a specific feature when not using Git branches.**Must be set in the context of the agent you're working with prior to using /speckit.plan or follow-up commands. |
Spec Kit can be tailored to your needs through two complementary systems — extensions and presets — plus project-local overrides for one-off adjustments:
| Priority | Component Type | Location |
|---|---|---|
| ⬆ 1 | Project-Local Overrides | .specify/templates/overrides/ |
| 2 | Presets — Customize core & extensions | .specify/presets/templates/ |
| 3 | Extensions — Add new capabilities | .specify/extensions/templates/ |
| ⬇ 4 | Spec Kit Core — Built-in SDD commands & templates | .specify/templates/ |
.specify/templates/overrides/) let you make one-off adjustments for a single project without creating a full preset.specify extension add or specify preset add, command files are written into agent directories (e.g., .claude/commands/).Use extensions when you need functionality that goes beyond Spec Kit's core. Extensions introduce new commands and templates — for example, adding domain-specific workflows that are not covered by the built-in SDD commands, integrating with external tools, or adding entirely new development phases. They expand what Spec Kit can do.
# Search available extensions
specify extension search
# Install an extension
specify extension add <extension-name>
For example, extensions could add Jira integration, post-implementation code review, V-Model test traceability, or project health diagnostics.
See the Extensions README for the full guide and how to build and publish your own. Browse the community extensions above for what's available.
Use presets when you want to change how Spec Kit works without adding new capabilities. Presets override the templates and commands that ship with the core and with installed extensions — for example, enforcing a compliance-oriented spec format, using domain-specific terminology, or applying organizational standards to plans and tasks. They customize the artifacts and instructions that Spec Kit and its extensions produce.
# Search available presets
specify preset search
# Install a preset
specify preset add <preset-name>
For example, presets could restructure spec templates to require regulatory traceability, adapt the workflow to fit the methodology you use (e.g., Agile, Kanban, Waterfall, jobs-to-be-done, or domain-driven design), add mandatory security review gates to plans, enforce test-first task ordering, or localize the entire workflow to a different language. The pirate-speak demo shows just how deep the customization can go. Multiple presets can be stacked with priority ordering.
See the Presets README for the full guide, including resolution order, priority, and how to create your own.
| Goal | Use |
|---|---|
| Add a brand-new command or workflow | Extension |
| Customize the format of specs, plans, or tasks | Preset |
| Integrate an external tool or service | Extension |
| Enforce organizational or regulatory standards | Preset |
| Ship reusable domain-specific templates | Either — presets for template overrides, extensions for templates bundled with new commands |
Spec-Driven Development is a structured process that emphasizes:
| Phase | Focus | Key Activities |
|---|---|---|
| 0-to-1 Development ("Greenfield") | Generate from scratch |
|
| Creative Exploration | Parallel implementations |
|
| Iterative Enhancement ("Brownfield") | Brownfield modernization |
|
Our research and experimentation focus on:
If you encounter issues with an agent, please open an issue so we can refine the integration.
You can use the Specify CLI to bootstrap your project, which will bring in the required artifacts in your environment. Run:
specify init <project_name>
Or initialize in the current directory:
specify init .
# or use the --here flag
specify init --here
# Skip confirmation when the directory already has files
specify init . --force
# or
specify init --here --force
You will be prompted to select the AI agent you are using. You can also proactively specify it directly in the terminal:
specify init <project_name> --ai claude
specify init <project_name> --ai gemini
specify init <project_name> --ai copilot
# Or in current directory:
specify init . --ai claude
specify init . --ai codex --ai-skills
# or use --here flag
specify init --here --ai claude
specify init --here --ai codex --ai-skills
# Force merge into a non-empty current directory
specify init . --force --ai claude
# or
specify init --here --force --ai claude
The CLI will check if you have Claude Code, Gemini CLI, Cursor CLI, Qwen CLI, opencode, Codex CLI, Qoder CLI, Tabnine CLI, Kiro CLI, Pi, Forge, Goose, or Mistral Vibe installed. If you do not, or you prefer to get the templates without checking for the right tools, use --ignore-agent-tools with your command:
specify init <project_name> --ai claude --ignore-agent-tools
Go to the project folder and run your AI agent. In our example, we're using claude.
You will know that things are configured correctly if you see the /speckit.constitution, /speckit.specify, /speckit.plan, /speckit.tasks, and /speckit.implement commands available.
The first step should be establishing your project's governing principles using the /speckit.constitution command. This helps ensure consistent decision-making throughout all subsequent development phases:
/speckit.constitution Create principles focused on code quality, testing standards, user experience consistency, and performance requirements. Include governance for how these principles should guide technical decisions and implementation choices.
This step creates or updates the .specify/memory/constitution.md file with your project's foundational guidelines that the AI agent will reference during specification, planning, and implementation phases.
With your project principles established, you can now create the functional specifications. Use the /speckit.specify command and then provide the concrete requirements for the project you want to develop.
[!IMPORTANT]
Be as explicit as possible about what you are trying to build and why. Do not focus on the tech stack at this point.
An example prompt:
Develop Taskify, a team productivity platform. It should allow users to create projects, add team members,
assign tasks, comment and move tasks between boards in Kanban style. In this initial phase for this feature,
let's call it "Create Taskify," let's have multiple users but the users will be declared ahead of time, predefined.
I want five users in two different categories, one product manager and four engineers. Let's create three
different sample projects. Let's have the standard Kanban columns for the status of each task, such as "To Do,"
"In Progress," "In Review," and "Done." There will be no login for this application as this is just the very
first testing thing to ensure that our basic features are set up. For each task in the UI for a task card,
you should be able to change the current status of the task between the different columns in the Kanban work board.
You should be able to leave an unlimited number of comments for a particular card. You should be able to, from that task
card, assign one of the valid users. When you first launch Taskify, it's going to give you a list of the five users to pick
from. There will be no password required. When you click on a user, you go into the main view, which displays the list of
projects. When you click on a project, you open the Kanban board for that project. You're going to see the columns.
You'll be able to drag and drop cards back and forth between different columns. You will see any cards that are
assigned to you, the currently logged in user, in a different color from all the other ones, so you can quickly
see yours. You can edit any comments that you make, but you can't edit comments that other people made. You can
delete any comments that you made, but you can't delete comments anybody else made.
After this prompt is entered, you should see Claude Code kick off the planning and spec drafting process. Claude Code will also trigger some of the built-in scripts to set up the repository.
Once this step is completed, you should have a new branch created (e.g., 001-create-taskify), as well as a new specification in the specs/001-create-taskify directory.
The produced specification should contain a set of user stories and functional requirements, as defined in the template.
At this stage, your project folder contents should resemble the following:
└── .specify
├── memory
│ └── constitution.md
├── scripts
│ ├── check-prerequisites.sh
│ ├── common.sh
│ ├── create-new-feature.sh
│ ├── setup-plan.sh
│ └── update-claude-md.sh
├── specs
│ └── 001-create-taskify
│ └── spec.md
└── templates
├── plan-template.md
├── spec-template.md
└── tasks-template.md
With the baseline specification created, you can go ahead and clarify any of the requirements that were not captured properly within the first shot attempt.
You should run the structured clarification workflow before creating a technical plan to reduce rework downstream.
Preferred order:
/speckit.clarify (structured) – sequential, coverage-based questioning that records answers in a Clarifications section.If you intentionally want to skip clarification (e.g., spike or exploratory prototype), explicitly state that so the agent doesn't block on missing clarifications.
Example free-form refinement prompt (after /speckit.clarify if still needed):
For each sample project or project that you create there should be a variable number of tasks between 5 and 15
tasks for each one randomly distributed into different states of completion. Make sure that there's at least
one task in each stage of completion.
You should also ask Claude Code to validate the Review & Acceptance Checklist, checking off the things that are validated/pass the requirements, and leave the ones that are not unchecked. The following prompt can be used:
Read the review and acceptance checklist, and check off each item in the checklist if the feature spec meets the criteria. Leave it empty if it does not.
It's important to use the interaction with Claude Code as an opportunity to clarify and ask questions around the specification - do not treat its first attempt as final.
You can now be specific about the tech stack and other technical requirements. You can use the /speckit.plan command that is built into the project template with a prompt like this:
We are going to generate this using .NET Aspire, using Postgres as the database. The frontend should use
Blazor server with drag-and-drop task boards, real-time updates. There should be a REST API created with a projects API,
tasks API, and a notifications API.
The output of this step will include a number of implementation detail documents, with your directory tree resembling this:
.
├── CLAUDE.md
├── memory
│ └── constitution.md
├── scripts
│ ├── check-prerequisites.sh
│ ├── common.sh
│ ├── create-new-feature.sh
│ ├── setup-plan.sh
│ └── update-claude-md.sh
├── specs
│ └── 001-create-taskify
│ ├── contracts
│ │ ├── api-spec.json
│ │ └── signalr-spec.md
│ ├── data-model.md
│ ├── plan.md
│ ├── quickstart.md
│ ├── research.md
│ └── spec.md
└── templates
├── CLAUDE-template.md
├── plan-template.md
├── spec-template.md
└── tasks-template.md
Check the research.md document to ensure that the right tech stack is used, based on your instructions. You can ask Claude Code to refine it if any of the components stand out, or even have it check the locally-installed version of the platform/framework you want to use (e.g., .NET).
Additionally, you might want to ask Claude Code to research details about the chosen tech stack if it's something that is rapidly changing (e.g., .NET Aspire, JS frameworks), with a prompt like this:
I want you to go through the implementation plan and implementation details, looking for areas that could
benefit from additional research as .NET Aspire is a rapidly changing library. For those areas that you identify that
require further research, I want you to update the research document with additional details about the specific
versions that we are going to be using in this Taskify application and spawn parallel research tasks to clarify
any details using research from the web.
During this process, you might find that Claude Code gets stuck researching the wrong thing - you can help nudge it in the right direction with a prompt like this:
I think we need to break this down into a series of steps. First, identify a list of tasks
that you would need to do during implementation that you're not sure of or would benefit
from further research. Write down a list of those tasks. And then for each one of these tasks,
I want you to spin up a separate research task so that the net results is we are researching
all of those very specific tasks in parallel. What I saw you doing was it looks like you were
researching .NET Aspire in general and I don't think that's gonna do much for us in this case.
That's way too untargeted research. The research needs to help you solve a specific targeted question.
[!NOTE]
Claude Code might be over-eager and add components that you did not ask for. Ask it to clarify the rationale and the source of the change.
With the plan in place, you should have Claude Code run through it to make sure that there are no missing pieces. You can use a prompt like this:
Now I want you to go and audit the implementation plan and the implementation detail files.
Read through it with an eye on determining whether or not there is a sequence of tasks that you need
to be doing that are obvious from reading this. Because I don't know if there's enough here. For example,
when I look at the core implementation, it would be useful to reference the appropriate places in the implementation
details where it can find the information as it walks through each step in the core implementation or in the refinement.
This helps refine the implementation plan and helps you avoid potential blind spots that Claude Code missed in its planning cycle. Once the initial refinement pass is complete, ask Claude Code to go through the checklist once more before you can get to the implementation.
You can also ask Claude Code (if you have the GitHub CLI installed) to go ahead and create a pull request from your current branch to main with a detailed description, to make sure that the effort is properly tracked.
[!NOTE]
Before you have the agent implement it, it's also worth prompting Claude Code to cross-check the details to see if there are any over-engineered pieces (remember - it can be over-eager). If over-engineered components or decisions exist, you can ask Claude Code to resolve them. Ensure that Claude Code follows the constitution as the foundational piece that it must adhere to when establishing the plan.
With the implementation plan validated, you can now break down the plan into specific, actionable tasks that can be executed in the correct order. Use the /speckit.tasks command to automatically generate a detailed task breakdown from your implementation plan:
/speckit.tasks
This step creates a tasks.md file in your feature specification directory that contains:
[P] to optimize development workflowThe generated tasks.md provides a clear roadmap for the /speckit.implement command, ensuring systematic implementation that maintains code quality and allows for incremental delivery of user stories.
Once ready, use the /speckit.implement command to execute your implementation plan:
/speckit.implement
The /speckit.implement command will:
tasks.md[!IMPORTANT]
The AI agent will execute local CLI commands (such asdotnet,npm, etc.) - make sure you have the required tools installed on your machine.
Once the implementation is complete, test the application and resolve any runtime errors that may not be visible in CLI logs (e.g., browser console errors). You can copy and paste such errors back to your AI agent for resolution.
If you're having issues with Git authentication on Linux, you can install Git Credential Manager:
#!/usr/bin/env bash
set -e
echo "Downloading Git Credential Manager v2.6.1..."
wget https://github.com/git-ecosystem/git-credential-manager/releases/download/v2.6.1/gcm-linux_amd64.2.6.1.deb
echo "Installing Git Credential Manager..."
sudo dpkg -i gcm-linux_amd64.2.6.1.deb
echo "Configuring Git to use GCM..."
git config --global credential.helper manager
echo "Cleaning up..."
rm gcm-linux_amd64.2.6.1.deb
For support, please open a GitHub issue. We welcome bug reports, feature requests, and questions about using Spec-Driven Development.
This project is heavily influenced by and based on the work and research of John Lam.
This project is licensed under the terms of the MIT open source license. Please refer to the LICENSE file for the full terms.