Spec-Driven Development

Think First, Prompt Second. A structured AI engineering workflow that enforces Analyze -> Plan -> Ask -> Execute -> Review cycles for spec-aligned, pattern-consistent implementations.

Stop vibe coding. Start spec coding.

What It Does

Prevents the most common AI coding failures:

Problem	How SDD Fixes It
Vibe coding	Mandatory analysis + planning before any code
Over-scoping	Phase boundaries enforce <200 lines per commit
Pattern violations	Analyzer searches codebase patterns before planning
Reinventing the wheel	Analyzer finds similar implementations to reuse
Big-bang commits	Phase-by-phase commits enforced
Spec drift	Reviewer checks against acceptance criteria

Install

npx skills add TadejPolajnar/spec-driven-development

The Workflow

Spec ──> Analyze ──> Plan ──> [Approval] ──> Ask ──> Execute ──> Commit ──> Review
            │          │                      │                               │
            │          │   scope changed  ◄───┘                               │
            │          │        │                                             │
            │          │ ◄──────┘                                             │
            │          │                                                      │
            │          │ ◄──  plan invalid  ◄─────────────────────────────────┤
            │          │                                                      │
            ◄───────── │ new requirements  ◄──────────────────────────────────┘
                                                                   │
                                                         more phases?  ──>  Done

Phase 1 — Analyze

Reads the spec, maps the codebase architecture, finds similar implementations to reuse, identifies integration points and risks. No code written.

Phase 2 — Plan

Breaks the feature into phases (<200 lines each), references existing patterns by file path, defines tests per phase. Stops for user approval.

Phase 3 — Ask

Surfaces ambiguities, proposes alternatives for architectural decisions. Natural conversation pause — no special process.

Phase 4 — Execute

Implements one phase at a time following existing codebase patterns. Commits after each phase.

Phase 5 — Review

Verifies against spec acceptance criteria. Checks for bugs, edge cases, scope creep, architectural drift. Supports multi-perspective review on request.

Usage

Claude Code

Already works after install. Start a conversation and reference your spec:

Implement this feature per the spec: [paste spec or link]

Or invoke the skill directly:

/spec-driven-development

Other Agents (Cursor, Windsurf, Codex, 40+ more)

After install, the skill auto-loads. Just start with your spec — the agent will follow the workflow.

Supports 41 agents via skills.sh.

Structure

skills/
  spec-driven-development/
    SKILL.md    # Complete skill — all phases inline

License

MIT