🔧 Prerequisites

• Linux/macOS/Windows
• Supported AI coding agent.
• uv for package management (recommended) or pipx for persistent installation
• Python 3.11+
• Git

If you encounter issues with an agent, please open an issue so we can refine the integration.

1. Install Specify CLI

Requires uv (install uv). Replace vX.Y.Z with the latest release tag from Releases — keep the leading v (for example, v0.12.11, not 0.12.11):

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

Prefer installing from PyPI? The specify-cli package is also published there:

uv tool install specify-cli

See the Installation Guide for alternative methods, verification, upgrade, and troubleshooting.

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 reference for the full command guide. Browse the community extensions for what's available.

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 reference for the full command guide, including resolution order and priority stacking.

📦 Bundles: Role-Based Setups

Extensions and presets are individual building blocks. A bundle packages a curated set of them — extensions, presets, steps, and workflows — into a single, versioned, role-oriented setup so a whole team persona (product manager, business analyst, security researcher, developer, …) can be provisioned with one command.

A bundle is described by a hand-written bundle.yml manifest. It pins each component to a version and, optionally, targets a specific integration; a bundle with no integration is agnostic and inherits whatever integration the project already uses.

```bash

Inspect the exact component set a bundle will add (equals what install does)

specify bundle info <bundle-id>

Install a bundle's full component set in one operation

specify bundle install <bundle-id>

See what's installed, then update or remove non-destructively

specify bundle list specify bundle update <bundle-id> # or --all specify bundle remove <bundle-id> # removes only this bundle's components

Bundles resolve from a **priority-ordered catalog stack** (project > user >
built-in). Each source carries an install policy: `install-allowed` sources can
be installed from, while `discovery-only` sources are visible in `search`/`info`
but refuse installation. Manage the stack with `specify bundle catalog list|add|remove`.

Authors validate and package bundles locally. Distribution is hosting the built
artifact and adding a catalog source; community bundle submissions use the
[Bundle Submission](https://github.com/github/spec-kit/issues/new?template=bundle_submission.yml)
issue template so required component catalogs and install evidence can be reviewed:

Four ready-to-read example bundle manifests live under examples/bundles/ (product manager, business analyst, security researcher, developer). These are bundle packaging examples, not filled generated feature specs; for end-to-end community examples, see the community walkthroughs.

Key guarantees: info shows exactly what install adds (transparency); installs are idempotent and confined to the project root; remove never touches components another installed bundle still needs; and all consume/author commands work offline against local or pinned sources.

SDD Quickstart

Replace vX.Y.Z with the latest release tag, keeping the leading v.

uv tool install specify-cli --from git+https://github.com/github/spec-kit.git@vX.Y.Z
specify init my-project --integration copilot
cd my-project

Launch your coding agent in the project directory, then:

1. Establish your project principles once (/speckit-constitution). This is a one-time step per project.
2. Specify what you want to build (/speckit-specify).
3. Plan how you will build it (/speckit-plan).
4. Break down the plan into actionable tasks (/speckit-tasks).
5. Implement the tasks (/speckit-implement).
6. Converge the implementation against the spec, plan, and tasks (/speckit-converge).

[!NOTE] Repeat steps 4 and 5 until /speckit-converge reports Converged.

Bug Fix Quickstart

Replace vX.Y.Z with the latest release tag, keeping the leading v.

uv tool install specify-cli --from git+https://github.com/github/spec-kit.git@vX.Y.Z
specify init my-project --integration copilot
cd my-project
specify extension add bug

Launch your coding agent in the project directory, then:

1. Assess the bug (/speckit-bug-assess "<bug report>" slug=login-crash).
2. Fix the assessed cause (/speckit-bug-fix slug=login-crash).
3. Test the fix (/speckit-bug-test slug=login-crash).

Idea Assessment Quickstart

Replace vX.Y.Z with the latest release tag, keeping the leading v.

uv tool install specify-cli --from git+https://github.com/github/spec-kit.git@vX.Y.Z
specify init my-project --integration copilot
cd my-project
specify extension add assess

Launch your coding agent in the project directory, then:

1. Intake the idea (/speckit-assess-intake "<idea>" slug=offline-mode).
2. Research supporting and opposing evidence (/speckit-assess-research slug=offline-mode).
3. Define the problem, goals, and success metrics (/speckit-assess-define slug=offline-mode).
4. Shape possible solutions and their trade-offs (/speckit-assess-shape slug=offline-mode).
5. Decide whether to proceed, clarify, or stop (/speckit-assess-decide slug=offline-mode).

[!NOTE] Idea assessment is standalone. If you choose to build an idea with a go decision, you can hand it off to /speckit-specify.

Optional Commands

Additional commands for enhanced quality and validation:

🔧 Specify CLI Reference

For full command details, options, and examples, see the CLI Reference.

🤖 Supported AI Coding Agent Integrations

Spec Kit works with 30+ AI coding agents — both CLI tools and IDE-based assistants. See the full list with notes and usage details in the Supported AI Coding Agent Integrations guide.

Run specify integration list to see all available integrations in your installed version.

🧩 Making Spec Kit Your Own: Extensions & Presets

Spec Kit can be tailored to your needs through two complementary systems — extensions and presets — plus project-local overrides for one-off adjustments:

• Templates are resolved at runtime — Spec Kit walks the stack top-down and uses the first match.
• Project-local overrides (.specify/templates/overrides/) let you make one-off adjustments for a single project without creating a full preset.
• Extension/preset commands are applied at install time — when you run specify extension add or specify preset add, command files are written into agent directories (e.g., .claude/commands/).
• If multiple presets or extensions provide the same command, the highest-priority version wins. On removal, the next-highest-priority version is restored automatically.
• If no overrides or customizations exist, Spec Kit uses its core defaults.

Search available extensions

specify extension search

Presets — Customize Existing Workflows

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.

```bash

Upgrade in place to the latest stable release (auto-detects uv tool vs pipx install)

specify self upgrade