spec-kit

Implements a five-phase specification-to-code pipeline (Constitution → Specify → Plan → Tasks → Implement) where each phase generates executable artifacts that feed into the next. Uses a resumable workflow engine (v0.7.0+) that persists execution state, allowing developers to pause/resume multi-step AI-assisted development without losing context. The specify CLI orchestrates phase transitions via slash commands (/speckit.specify, /speckit.plan, /speckit.tasks, /speckit.implement) that generate structured markdown documents in .specify/memory/ and specs/ directories, making specifications machine-readable and directly consumable by AI agents.

Maintains an INTEGRATION_REGISTRY that abstracts 30+ AI coding agents (GitHub Copilot, Claude, Devin, etc.) behind a unified interface. Each agent has a standardized directory structure (.specify/agents/{agent_name}/) where context files, prompts, and agent-specific configuration are stored. The system provides Agent Context Management that automatically updates agent-specific context based on project state, allowing the same specification to be executed by different agents without manual context switching. Supports native function-calling APIs for OpenAI, Anthropic, and other providers.

Maintains community-contributed catalogs (presets/catalog.community.json, extensions/catalog.community.json) that allow teams to discover and reuse presets and extensions created by other organizations. The catalog system provides metadata for each preset/extension (name, description, author, version, compatibility), enabling teams to search and filter by use case. Teams can publish their own presets and extensions to the community catalog via a standardized submission process. The specify preset and specify extension commands allow teams to browse, install, and manage presets/extensions from the catalog. Catalogs are versioned and support dependency resolution for extensions that depend on other extensions.

Implements Agent Context Management that automatically injects project context (constitution, specifications, task lists, code snippets) into prompts sent to AI agents. The system maintains a context budget (respecting agent token limits) and uses intelligent summarization to fit relevant context within available tokens. Context injection is phase-aware: specification generation includes constitution and project structure; implementation includes specification, tasks, and relevant code examples. The system supports context caching (where available) to reduce token usage across multiple agent calls. Custom context processors can be defined via extensions to inject domain-specific context (e.g., API schemas, database migrations).

Implements the /speckit.implement slash command that orchestrates AI agents to generate working implementation code from specifications and task lists. The implementation phase passes the specification, tasks, constitution, and relevant code examples to the selected AI agent, which generates code that satisfies the specification requirements. The system supports multiple implementation strategies: single-agent implementation (one agent generates all code), multi-agent implementation (different agents handle different components), and incremental implementation (agents implement tasks sequentially). Implementation artifacts are validated against specification requirements, and failures trigger re-generation with additional context or agent switching.

Implements a three-tier template resolution system (project-level → preset → default templates) that generates specifications and task lists from natural language inputs. The Preset System provides reusable template catalogs (presets/catalog.community.json) that define document templates, command templates, and workflow step types. When a developer runs /speckit.specify or /speckit.tasks, the system resolves the appropriate template, interpolates variables from project context, and generates structured markdown documents. Templates support Jinja2-style variable substitution and conditional sections, enabling flexible specification generation across different project types and domains.

Provides an Extension Architecture that allows developers to define custom slash commands (e.g., /speckit.custom-command) and workflow step types without modifying core Spec Kit code. Extensions are registered via extensions/catalog.community.json and loaded dynamically at runtime. Each extension can define custom command handlers, template processors, and workflow step implementations. The system supports extension composition, allowing extensions to depend on and build upon other extensions. Extension development follows a standardized interface with hooks for pre/post-processing, context injection, and output formatting.

Transforms natural language feature descriptions into machine-readable specifications through the /speckit.specify slash command. The system uses AI agents to analyze feature requirements, extract key components (inputs, outputs, constraints, acceptance criteria), and generate structured Markdown documents in specs/NNN-feature/spec.md. The specification format is designed to be both human-readable and machine-parseable, with sections for API contracts, data models, error handling, and edge cases. The generated specifications serve as the primary input for downstream phases (planning, task generation, implementation), ensuring AI agents have precise, unambiguous requirements.

Implements the /speckit.plan and /speckit.tasks commands that decompose specifications into actionable development tasks. The planning phase analyzes the specification document and generates a structured plan (specs/NNN-feature/plan.md) that breaks down the feature into implementation phases, identifies dependencies, and estimates complexity. The tasks phase further decomposes the plan into granular tasks (specs/NNN-feature/tasks.md) with clear acceptance criteria, estimated effort, and prerequisite tasks. The decomposition uses AI agents to understand specification semantics and generate realistic task breakdowns that account for testing, documentation, and integration work.

Implements the specify init command that bootstraps a new Spec Kit project by detecting project language, framework, and architecture. The initialization process creates the .specify/ directory structure, initializes configuration files, and sets up the INTEGRATION_REGISTRY for the detected tech stack. The system analyzes existing code (if present) to infer project structure, dependencies, and conventions, then generates a constitution document (.specify/memory/constitution.md) that captures project context. Initialization supports multiple languages (Python, JavaScript, Go, Rust, etc.) and frameworks (Django, FastAPI, React, etc.) with language-specific templates and presets.

Implements the /speckit.constitution slash command that generates a constitution document (.specify/memory/constitution.md) capturing project-wide context, conventions, and constraints. The constitution serves as a persistent knowledge base that AI agents reference during all development phases. It includes project metadata (name, language, framework), architectural patterns, coding standards, directory structure, key dependencies, and project-specific constraints. The constitution is generated once during initialization and can be updated via the /speckit.constitution command. All downstream phases (specification, planning, implementation) include the constitution in agent context, ensuring consistency across AI-assisted development.

Implements a Workflow System that allows teams to define custom development workflows as YAML files with typed step definitions. Each workflow step has a type (e.g., 'specify', 'plan', 'implement', 'test', 'deploy') and can execute custom commands, invoke AI agents, or trigger external tools. Steps support conditional execution, error handling, and output passing between steps. The workflow engine maintains execution state in .specify/workflows/, enabling resumable execution and rollback. Workflows can be composed from reusable step templates and published to the community catalog for sharing. The system supports both sequential and parallel step execution (where applicable).

Implements the specify check and specify version commands that validate specifications for completeness, consistency, and compatibility with downstream phases. The validation system checks that specifications include required sections (API contracts, data models, acceptance criteria), validates that task lists align with specification scope, and ensures implementation artifacts match specification requirements. The version command tracks specification versions and detects breaking changes when specifications are updated. Validation rules can be customized via extensions, allowing teams to enforce domain-specific constraints (e.g., API versioning policies, security requirements).