Spec Kit

spec-kit — Spec-Driven Development via specify

GitHub's spec-kit inverts the usual flow: specifications become executable and directly drive implementation. This skill is the routing-first wrapper around the upstream specify CLI — it installs the tool, bootstraps a project for a chosen AI agent, and walks the five-step SDD command pipeline.

When to use this skill

• The user asks to install spec-kit, specify-cli, or "GitHub spec kit"
• The user wants to start a project with a Spec-Driven Development workflow
• The user types or asks about /speckit.constitution, /speckit.specify,

/speckit.plan, /speckit.tasks, /speckit.implement, /speckit.clarify, /speckit.analyze, or /speckit.checklist

• The user wants to share an executable spec across Claude Code, Copilot,

Gemini, Cursor, Codex, opencode, Qwen, Kiro, or another supported agent

• The user wants to discover community spec-kit extensions or presets

(specify extension search, specify preset search)

When not to use this skill

• The user wants a vendor-neutral packet-first planning router that

classifies the next BMAD artifact → use bmad

• The user needs a **spec-first control loop with immutable seed and

drift-aware execution** independent of GitHub spec-kit → use ooo

• The user wants visual review/approval of an existing plan or diff →

use plannotator

• The user wants pre-planning concept framing (problem, audience,

positioning) before any spec exists → use bmad-idea

Prerequisites

Instructions

Step 1 — Install specify-cli

# Recommended: uv tool install (pins via Git ref)
uv tool install specify-cli --from git+https://github.com/github/spec-kit.git

# Pinned to a tag (reproducibility):
uv tool install specify-cli --from git+https://github.com/github/spec-kit.git@v0.0.10

# Alternative: pipx
pipx install git+https://github.com/github/spec-kit.git

# Verify
specify --version
specify integration list

Step 2 — Pick the target AI agent

specify integration list prints all supported agents. Common options:

Step 3 — Initialize the project

# Create a new project directory and bootstrap it
specify init my-project --integration claude

# Bootstrap in the current directory
specify init . --integration copilot

# Force-overwrite into the current directory
specify init --here --force --integration gemini

This writes .specify/, agent-specific command files, and the constitution template.

Step 4 — Drive the SDD command pipeline

Run these slash commands inside the chosen agent (Claude Code, Copilot, Gemini, etc.). The agent reads files written by specify init.

Optional refinements:

• /speckit.clarify — interview to resolve ambiguity in the spec
• /speckit.analyze — review consistency between constitution, spec, plan
• /speckit.checklist — generate quality checklists for review gates

Step 5 — Extensions and presets (community)

specify extension search
specify extension add <extension-name>

specify preset search
specify preset add <preset-name>

Browse community resources at <https://github.github.io/spec-kit/community/>.

Step 6 — Plugin-style installation alongside jeo-skills

This skill folder is plugin-installable through the standard jeo-skills flow so the wrapper, references, and installer script land on disk for any supported agent runtime:

# Project install (writes into .agents/skills/spec-kit/)
npx skills add https://github.com/akillness/jeo-skills --skill spec-kit

# Global install for every detected agent
npx skills add -g https://github.com/akillness/jeo-skills --skill spec-kit

# Target specific agents
npx skills add -g https://github.com/akillness/jeo-skills --skill spec-kit -a claude-code -a codex -y

The skill also ships `scripts/install.sh` as a one-shot installer that detects uv / pipx and runs Step 1.

Output format

When the user asks spec-kit for help, return a compact brief:

# spec-kit Routing Brief

## Scope
- Target agent: claude | copilot | gemini | codex | cursor | opencode | ...
- Project state: new | existing-init | mid-pipeline | extension-only
- Pipeline stage: constitution | specify | plan | tasks | implement | clarify | analyze | checklist

## Recommended next move
- install-specify | specify-init | run-/speckit.<command> | add-extension

## Why
- 2-3 bullets grounded in the user's packet

## Route-outs
- `ooo` for vendor-neutral spec-first loops
- `bmad` for packet-first BMAD/BMM artifact selection
- `plannotator` for approval/review of an existing plan

Best practices

1. Pin a Git ref (@v0.0.10 or a commit SHA) when reproducibility is important — main moves. 2. One integration per repo unless the user explicitly wants multi-agent parity; switching --integration rewrites command files. 3. Treat `/speckit.constitution` as load-bearing — downstream /speckit.plan and /speckit.tasks honor it, so update it first when principles drift. 4. Use `/speckit.clarify` before `/speckit.plan` when the spec is ambiguous instead of letting the plan paper over open questions. 5. Hand off the artifact to `plannotator` for explicit review before /speckit.implement on level 2+ work. 6. Route to `ooo` when the user actually wants a vendor-neutral spec-first loop with drift tracking instead of GitHub's pipeline.

References

• Upstream repo: <https://github.com/github/spec-kit>
• Documentation site: <https://github.github.io/spec-kit/>
• Community presets and extensions: <https://github.github.io/spec-kit/community/>
• Installer script: `scripts/install.sh`
• Command reference: `references/commands.md`
• Adjacent skills: ../ooo/SKILL.md, ../bmad/SKILL.md,

../plannotator/SKILL.md, ../bmad-idea/SKILL.md

• License: MIT (see upstream LICENSE)

spec-kit command reference

Upstream: <https://github.com/github/spec-kit>

CLI (specify)

Slash commands (run inside the chosen agent)

Recommended order

1. /speckit.constitution — once, then revisit when principles change 2. /speckit.specify — describe the change in product language 3. /speckit.clarify — only if the spec has open questions 4. /speckit.plan — generate the technical strategy 5. /speckit.analyze — verify the plan honors the spec + constitution 6. /speckit.tasks — decompose into independently runnable tasks 7. /speckit.checklist — produce gate-ready review artifacts 8. /speckit.implement — execute, one task at a time

Supported integrations (selected)

specify integration list is authoritative. Common values:

• claude — Claude Code
• copilot — GitHub Copilot
• gemini — Google Gemini CLI
• codex — OpenAI Codex CLI
• cursor — Cursor CLI
• opencode — opencode
• qwen — Qwen CLI
• kiro — Kiro CLI
• tabnine, mistral, goose, forge, pi, and 15+ others