Skip to content
Skills Library
Programming · Planning

speckit

/speckit

Specification-Driven Development (SDD) toolkit. Transforms ideas into executable specifications, implementation plans, and task lists. Use for feature planning, PRD creation, or when user invokes /speckit.specify, /speckit.plan, /speckit.tasks commands.

Repository
a-i--skills ↗
Licence
Apache-2.0
Last repository change
24.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
12
Scripts
2
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 24.10.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What to check before installing
  • 2 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/init_spec_dir.py, scripts/validate_spec.py

What it does and when to use it

Specification-Driven Development (SDD) toolkit. Transforms ideas into executable specifications, implementation plans, and task lists. Use for feature planning, PRD creation, or when user invokes /speckit.specify, /speckit.plan, /speckit.tasks commands.

Original author description

Specification-Driven Development (SDD) toolkit. Transforms ideas into executable specifications, implementation plans, and task lists. Use for feature planning, PRD creation, or when user invokes /speckit.specify, /speckit.plan, /speckit.tasks commands.

How it works

  1. Overview
  2. Commands
  3. Workflow Example
  4. Project Constitution
  5. Key Concepts
  6. File Locations
  7. Reference Files
Original SKILL.md headings · 193 lines, 800 words
SKILL.md preview
---
name: speckit
description: Specification-Driven Development (SDD) toolkit. Transforms ideas into executable specifications, implementation plans, and task lists. Use for feature planning, PRD creation, or when user invokes /speckit.specify, /speckit.plan, /speckit.tasks commands.
license: MIT
governance_phases: [frame, shape]
organ_affinity: [organ-iv]
triggers: [user-asks-about-specifications, command:speckit, context:specification]
---

# Spec Kit: Specification-Driven Development

## Overview

Spec Kit implements **Specification-Driven Development (SDD)** - a methodology where specifications drive code, not vice versa. Instead of specs serving as documentation for code, code becomes the expression of specifications.

### The Power Inversion

Traditional development: Code is truth, specs are scaffolding
**SDD**: Specifications are truth, code is generated output

This eliminates the gap between intent and implementation by making specifications executable through AI.

## Commands

### `/speckit.specify <feature-description>`

Creates a comprehensive feature specification from a natural language description.

**Usage**: `/speckit.specify Real-time chat with message history and presence`

**Output**:
- `specs/{feature-name}/spec.md` - Complete feature specification
- `specs/{feature-name}/checklists/requirements.md` - Quality validation checklist

**Process**:
1. Parse user description, extract key concepts (actors, actions, data, constraints)
2. Generate user scenarios with prioritized stories (P1, P2, P3)
3. Define functional requirements (FR-001, FR-002, etc.)
4. Create measurable success criteria
5. Identify key entities
6. Validate against quality checklist
7. Present clarification questions (max 3) if critical ambiguities exist

**Guidelines**:
- Focus on WHAT users need and WHY
- Avoid HOW (no tech stack, APIs, code structure)
- Make informed guesses using industry standards
- Limit `[NEEDS CLARIFICATION]` markers to 3 maximum
- Every requirement must be testable

For detailed template: read `assets/templates/spec-template.md`
For command details: read `references/commands/specify.md`

---

### `/speckit.plan [tech-context]`

Creates an implementation plan from an existing specification.

**Usage**: `/speckit.plan WebSocket, PostgreSQL, Redis` or `/speckit.plan` (will determine tech from context)

**Prerequisites**: `spec.md` must exist in the feature directory

**Output**:
- `specs/{feature}/plan.md` - Implementation plan with tech decisions
- `specs/{feature}/research.md` - Technology research and decisions
- `specs/{feature}/data-model.md` - Entity definitions
- `specs/{feature}/contracts/` - API specifications (OpenAPI/GraphQL)
- `specs/{feature}/quickstart.md` - Validation scenarios

**Process**:
1. Load feature specification and project constitution
2. Fill Technical Context section
3. Run Constitution Check (evaluate architectural gates)
4. Phase 0: Research unknowns, generate `research.md`
5. Phase 1: Design data models, generate contracts
6. Re-evaluate constitution compliance post-design

**Constitution Gates** (if using constitution):
- Simplicity Gate: Using ≤3 projects? No future-proofing?
- Anti-Abstraction Gate: Using framework directly?
- Integration-First Gate: Contracts defined?

For detailed template: read `assets/templates/plan-template.md`
For command details: read `references/commands/plan.md`

---

### `/speckit.tasks`

Generates an executable task list from the implementation plan.

**Usage**: `/speckit.tasks`

**Prerequisites**: `plan.md` and `spec.md` must exist

**Output**:
- `specs/{feature}/tasks.md` - Dependency-ordered task list

**Process**:
1. Load plan.md (tech stack, structure) and spec.md (user stories)
2. Optionally load: data-model.md, contracts/, research.md
3. Generate tasks organized by user story:
   - Phase 1: Setup (shared infrastructure)
   - Phase 2: Foundational (blocking prerequisites)
   - Phase 3+: User Stories in priority order (P1, P2, P3...)
   - Final Phase: Polish & cross-cutting
4. Mark parallelizable tasks with `[P]`
5. Number tasks (T001, T002...)
6. Generate dependency graph and parallel execution examples

**Task Format**: `[ID] [P?] [Story] Description`
- `[P]` = Can run in parallel (different files, no dependencies)
- `[Story]` = Which user story (US1, US2, US3)

For detailed template: read `assets/templates/tasks-template.md`
For command details: read `references/commands/tasks.md`

---

## Workflow Example

```bash
# 1. Create specification (5 min)
/speckit.specify Real-time chat with message history and user presence

# 2. Generate implementation plan (5 min)
/speckit.plan WebSocket for messaging, PostgreSQL for history, Redis for presence

# 3. Create task list (5 min)
/speckit.tasks
```

**Result** (in 15 minutes):
- Complete feature spec with user stories and acceptance criteria
- Detailed implementation plan with technology rationale
- API contracts and data models
- Executable task list organized by user story

## Project Constitution

A constitution defines immutable architectural principles for a project. When present at `memory/constitution.md`, the `/speckit.plan` command will:

1. Validate against constitutional gates before planning
2. Require justification for any violations
3. Track complexity deviations

**Sample principles**:
- Library-First: Features start as standalone libraries
- Test-First: TDD mandatory (Red-Green-Refactor)
- Simplicity: Maximum 3 projects, YAGNI
- Integration-First: Real databases over mocks

For constitution template: read `assets/templates/constitution-template.md`

## Key Concepts

### User Story Organization

Tasks are grouped by user story to enable:
- Independent implementation
- Independent testing
- Incremental delivery (ship P1, then P2, then P3)

### MVP-First Delivery

1. Complete Setup + Foundational phases
2. Implement User Story 1 (P1) → Test → Deploy
3. Add User Story 2 (P2) → Test → Deploy
4. Continue incrementally

### Template-Driven Quality

Templates constrain AI behavior for better outcomes:
- Prevent premature implementation details
- Force explicit uncertainty markers
- Enforce test-first thinking
- Prevent speculative features

## File Locations

When working in a project:
- Specifications: `specs/{feature-name}/`
- Constitution: `memory/constitution.md`

## Reference Files

### Templates (fill-in artifacts for output)

- `assets/templates/spec-template.md` - Feature specification template
- `assets/templates/plan-template.md` - Implementation plan template
- `assets/templates/tasks-template.md` - Task list template
- `assets/templates/constitution-template.md` - Project constitution template

### Documentation (methodology and command details)

- `references/methodology.md` - Full SDD philosophy document
- `references/commands/specify.md` - `/speckit.specify` command definition
- `references/commands/plan.md` - `/speckit.plan` command definition
- `references/commands/tasks.md` - `/speckit.tasks` command definition
Files in this package (12)
  • SKILL.md 7 KB
  • assets/templates/constitution-template.md 2 KB
  • assets/templates/plan-template.md 4 KB
  • assets/templates/spec-template.md 4 KB
  • assets/templates/tasks-template.md 9 KB
  • references/methodology.md 25 KB
  • references/workflow-integration.md 7 KB
  • references/commands/plan.md 4 KB
  • references/commands/specify.md 4 KB
  • references/commands/tasks.md 5 KB
  • scripts/init_spec_dir.py 4 KB
  • scripts/validate_spec.py 6 KB

Versions

RepositoryScoreLicence
This page · organvm-iv-taxis/a-i--skills100Apache-2.0
Tyler-R-Kendrick/agent-skills100MIT

Identical content appears in 4 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version 0e7dca0b99a7 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90speckit-orchestrator
    Orchestrates Spec Driven Development by coordinating spec, plan, and task skills. Use when running the full speckit workflow from spec to implementation.
  • 100speckit-workflow
    End-to-end Spec Kit lifecycle orchestrator that drives a single feature in an isolated git worktree from specification through planning, task generation, TDD implementation, verification, and automated pull request creation. Use when the user asks to "run speckit workflow",…
  • 100speckit-scripts
    Bundled Spec Kit automation scripts (bash + PowerShell) and artifact templates that back the /speckit:* commands. Use when a spec-driven workflow needs to create a feature, set up plan/tasks, or check prerequisites, and the target project has no .specify/ yet.
  • 100speckit-specify
    Create or update feature specifications from natural language descriptions. Use when starting new features or refining requirements. Generates spec.md with user stories, functional requirements, and acceptance criteria following spec-driven development methodology.
  • 86next
    Show a spec-kit feature's progress (a task is done when its issue is closed) and start the next open task with /speckit-implement; with several features, asks which. Use when the user asks what's next or has just merged a task PR.
  • 100spec-kit
    Spec Kit is GitHub's open-source toolkit that installs a set of agent commands into a project so a coding agent builds features from a written specification: specify, plan, tasks, implement, then converge against the spec. It also ships optional processes for bug fixing and for…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.