Skip to main content
Slash commands are AI-powered tools that guide you through the Spec-Driven Development (SDD) workflow. Each command represents a phase in the development process, from defining project principles to implementing features.

​
The SDD Workflow

Spec Kit organizes development into a structured, multi-phase workflow:
1

Constitution

Define your project’s core principles and governance rules using /speckit.constitution
2

Specify

Create feature specifications from natural language descriptions using /speckit.specify
3

Clarify (Optional)

Resolve ambiguities and refine requirements using /speckit.clarify
4

Plan

Generate technical architecture and design decisions using /speckit.plan
5

Tasks

Break down the plan into actionable, dependency-ordered tasks using /speckit.tasks
6

Analyze (Optional)

Validate consistency across all artifacts using /speckit.analyze
7

Checklist (Optional)

Generate quality validation checklists using /speckit.checklist
8

Implement

Execute the task plan and build the feature using /speckit.implement

​
Core Principles

​
Separation of Concerns

Each command has a specific responsibility:
  • What (Specification) comes before How (Planning)
  • Why (Requirements) drives What (Design)
  • Design (Architecture) comes before Do (Implementation)

​
Progressive Refinement

The workflow builds knowledge incrementally:
  1. Start with high-level user needs
  2. Clarify ambiguities through targeted questions
  3. Research technical approaches
  4. Design concrete solutions
  5. Execute in phases

​
Quality Gates

Each phase validates work before proceeding:
  • Constitution checks ensure alignment with project principles
  • Specification validation prevents ambiguous requirements
  • Plan validation resolves all technical unknowns
  • Task validation ensures complete coverage
  • Analysis detects inconsistencies across artifacts

​
Command Categories

​
Governance

/speckit.constitution

Define and maintain project principles, constraints, and governance rules

​
Feature Development

/speckit.specify

Create feature specifications from natural language

/speckit.clarify

Ask targeted questions to resolve specification ambiguities

/speckit.plan

Generate technical architecture and design artifacts

/speckit.tasks

Break plans into actionable, dependency-ordered tasks

​
Quality Assurance

/speckit.analyze

Detect inconsistencies and gaps across artifacts

/speckit.checklist

Generate domain-specific quality validation checklists

​
Execution

/speckit.implement

Execute the implementation plan by processing all tasks

​
Typical Workflows

​
New Feature - Full Workflow

# 1. Create specification
/speckit.specify Add user authentication with OAuth2

# 2. Clarify ambiguities (if needed)
/speckit.clarify

# 3. Generate technical plan
/speckit.plan I am building with Python and FastAPI

# 4. Create task breakdown
/speckit.tasks

# 5. Analyze for consistency (optional)
/speckit.analyze

# 6. Generate checklists (optional)
/speckit.checklist Create a security checklist

# 7. Execute implementation
/speckit.implement

​
Quick Feature - Skip Clarification

# For well-understood features, skip clarification
/speckit.specify Add pagination to user list endpoint
/speckit.plan
/speckit.tasks
/speckit.implement

​
Constitution Update

# Update project principles
/speckit.constitution Add principle: All APIs must be versioned

​
Handoffs and Automation

Commands can automatically hand off to the next phase:
After /speckit.specify completes, it suggests running /speckit.clarify or /speckit.plan.After /speckit.plan completes, it suggests running /speckit.tasks.After /speckit.tasks completes, it suggests running /speckit.analyze or /speckit.implement.

​
File Organization

Commands generate and read files in a structured hierarchy: 
.specify/
├── memory/
│   └── constitution.md          # Project principles (constitution)
└── templates/                   # Command templates

specs/
└── 001-feature-name/           # Feature branch number + name
    ├── spec.md                 # Feature specification (specify)
    ├── plan.md                 # Implementation plan (plan)
    ├── research.md             # Technical research (plan)
    ├── data-model.md           # Entity definitions (plan)
    ├── quickstart.md           # Integration guide (plan)
    ├── tasks.md                # Task breakdown (tasks)
    ├── contracts/              # API contracts (plan)
    │   └── *.md
    └── checklists/             # Quality checklists (checklist)
        └── *.md

​
Key Concepts

​
Feature Branches

Each feature gets a numbered branch:
  • Format: ###-feature-name (e.g., 001-user-auth)
  • Auto-incrementing across remote, local, and specs directories
  • Matches a corresponding specs/###-feature-name/ directory

​
Templates

All commands use templates from .specify/templates/:
  • Ensures consistent structure across features
  • Supports customization for project-specific needs
  • Validated during execution

​
Validation

Multiple validation layers:
  • Format validation: Ensures required sections exist
  • Content validation: Checks for placeholders and ambiguities
  • Cross-artifact validation: Detects inconsistencies (via analyze)
  • Constitution validation: Enforces project principles

​
Progressive Disclosure

Commands load only necessary context:
  • Reduces token usage
  • Focuses on relevant information
  • Supports large codebases

​
Best Practices

Always run commands in order: Each phase depends on the previous phase’s outputs. Skipping phases can lead to incomplete or inconsistent artifacts.

​
Start Simple

Begin with a minimal viable specification:
  • Focus on core user value
  • Add details through clarification
  • Let the AI infer reasonable defaults

​
Use Clarification Strategically

Only clarify what matters:
  • Scope boundaries that impact architecture
  • Security/privacy decisions
  • User experience trade-offs
  • Skip implementation details

​
Validate Early and Often

Run analysis before implementation:
  • Catch requirement gaps
  • Detect conflicting specifications
  • Verify constitution alignment
  • Ensure task coverage

​
Leverage Checklists

Generate domain-specific checklists:
  • Security requirements validation
  • UX requirement quality
  • API contract completeness
  • Performance requirement clarity

​
Next Steps

Constitution

Learn how to define project principles

Specify

Start creating feature specifications

Build docs developers (and LLMs) love

Get started for freeTalk to us