SDD Plugin for Claude Code

Spec-Driven Development — a Claude Code plugin that provides tools for managing specs, tracking progress, and implementing tasks.

What is SDD?

SDD uses a two-file data model to keep projects organized:

• specs/README.md — The checklist. Single source of truth for progress. Contains every task, phase, and spec's checkbox status.
• specs/spec-v{N}-*.md — The instructions. What needs to be done, why, and how. Full spec content with problem statement, requirements, and implementation phases.

The spec files are the reference material; the README is the scoreboard.

Installation

claude --plugin-dir /path/to/sdd-plugin

Or install from GitHub:

git clone https://github.com/jerichoBob/sdd-plugin.git
claude --plugin-dir ./sdd-plugin

Or add to your Claude Code settings to load automatically.

Commands

Command	Description	Auto-invocable
/sdd:specs	Status overview — progress table, staleness, drift detection	Yes
/sdd:specs --verify	Full status + code verification (checks implementations exist)	Yes
/sdd:next	Show the next task that would be implemented	Yes
/sdd:next-phase	Show all tasks in the current working phase	Yes
/sdd:code	Implement the single next task	No (user-triggered)
/sdd:code-spec [vN]	Implement ALL remaining tasks in a spec	No (user-triggered)
/sdd:code-phase	Implement all remaining tasks in current phase	No (user-triggered)
/sdd:spec <description>	Create a new spec from a description	No (user-triggered)
/sdd:specs-update	Sync project infrastructure (dirs, template, README, methodology)	No (user-triggered)
/sdd:spec-tagging	Reference doc for commit-tagging convention	Yes

How It Works

The Parse Script

scripts/specs-parse.sh is shared infrastructure that all skills call via dynamic context injection. It reads specs/README.md and outputs structured data so the LLM works with pre-parsed results instead of re-doing file I/O on every invocation.

Subcommands:

• status — TSV of version, name, done, total, status per spec
• next-task — First unchecked task with spec/phase context
• next-phase — All tasks in the current working phase
• staleness — Which spec files are newer than README
• structure — Validates specs/ directory structure
• spec-list — List of spec files with versions

Dynamic Context Injection

Skills use !`script` syntax to inject pre-parsed data before the LLM sees the prompt. This eliminates the token waste of re-parsing specs/README.md on every command invocation.

Required Project Structure

your-project/
├── specs/
│   ├── README.md              # Checklist — single source of truth
│   ├── TEMPLATE.md            # Spec template (created by /sdd:specs-update)
│   ├── spec-v1-feature.md     # Spec instructions
│   ├── spec-v2-feature.md
│   └── ...
└── ...

Run /sdd:specs-update in any project to create this structure.

Getting Started

1. Install the plugin: git clone https://github.com/jerichoBob/sdd-plugin.git && claude --plugin-dir ./sdd-plugin
2. In your project, run /sdd:specs-update to create the specs infrastructure
3. Create your first spec: /sdd:spec <describe what you want to build>
4. Check status: /sdd:specs
5. Start implementing: /sdd:code (one task) or /sdd:code-phase (full phase)

README Format

The specs/README.md uses this structure for each spec:

## v1: Feature Name

### Phase 1: Setup

- [x] Completed task
- [ ] Pending task

### Phase 2: Implementation

- [ ] Task 1
- [ ] Task 2

The parse script looks for:

• ## v{N}: {Name} or ## v{N} — {Name} — spec section headers
• ### Phase {N}: {Name} or ### {Name} — phase headers
• - [x] — completed tasks
• - [ ] — pending tasks