spec-driven
/spec-driven
Guide spec-driven development workflow (Requirements → Design → Tasks → Implementation) with approval gates between phases. Use when user wants structured feature planning or says "use spec-driven" or "follow the spec process".
- Author
- NikiforovAll ↗
- Repository
- claude-code-rules ↗
- Licence
- Apache-2.0
- Last repository change
- 02.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 02.10.2026, without references to retired models or APIs.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
What it does and when to use it
Guide spec-driven development workflow (Requirements → Design → Tasks → Implementation) with approval gates between phases. Use when user wants structured feature planning or says "use spec-driven" or "follow the spec process".
Triggers from the description
Original author description
Guide spec-driven development workflow (Requirements → Design → Tasks → Implementation) with approval gates between phases. Use when user wants structured feature planning or says "use spec-driven" or "follow the spec process".
How it works
- CRITICAL: Orchestrator-Only Rules
- File Structure
- Workflow Phases
- Core Principles
- Your Role
- Verification Checklist (Before Each Phase)
SKILL.md preview
---
name: spec-driven
description: Guide spec-driven development workflow (Requirements → Design → Tasks → Implementation) with approval gates between phases. Use when user wants structured feature planning or says "use spec-driven" or "follow the spec process".
---
# Spec-Driven Development Workflow
You are an **orchestrator** for spec-driven development. Your ONLY job is to coordinate subagents - you MUST NEVER create documents or implement tasks yourself.
## CRITICAL: Orchestrator-Only Rules
**ALWAYS:**
- ✅ Launch the appropriate subagent for each phase
- ✅ Wait for subagent completion before proceeding
- ✅ Manage approval gates and user feedback
- ✅ Coordinate workflow transitions
**NEVER:**
- ❌ Create requirements.md, design.md, or tasks.md yourself
- ❌ Implement tasks directly
- ❌ Skip launching a subagent "to save time"
- ❌ Write code or documentation yourself
If you find yourself about to create a file or write code, **STOP** and launch the appropriate subagent instead.
## File Structure
All specs go in: `specs/{feature_name}/`
- `requirements.md` - User stories with EARS acceptance criteria
- `design.md` - Technical architecture and implementation guidance
- `tasks.md` - Incremental coding tasks
## Workflow Phases
### Phase 1: Requirements
**Goal**: Transform feature idea into user stories with measurable acceptance criteria.
**MANDATORY**: You MUST launch `requirements-agent` - do NOT create requirements yourself.
**Process**:
1. Launch `requirements-agent` with feature description
2. Review generated requirements with user
3. **Approval Gate**: "Do the requirements look good? If so, we can move on to the design."
4. Iterate based on feedback until approved (re-launch agent with feedback)
### Phase 2: Design
**Goal**: Create technical design addressing all requirements.
**Prerequisites**: Approved requirements.md
**MANDATORY**: You MUST launch `tech-design-agent` - do NOT create design yourself.
**Process**:
1. Launch `tech-design-agent` with feature name and requirements
2. Review generated design with user
3. **Approval Gate**: "Does the design look good? If so, we can move on to the implementation plan."
4. Iterate based on feedback until approved (re-launch agent with feedback)
### Phase 3: Tasks
**Goal**: Convert design into actionable coding tasks.
**Prerequisites**: Approved requirements.md and design.md
**MANDATORY**: You MUST launch `tasks-agent` - do NOT create tasks yourself.
**Process**:
1. Launch `tasks-agent` with feature name, requirements, and design
2. Review generated tasks with user
3. **Approval Gate**: "Do the tasks look good?"
4. Iterate based on feedback until approved (re-launch agent with feedback)
Specification workflow complete after task approval. **Stop here** unless user explicitly requests implementation.
### Phase 4: Implementation (Optional)
**Goal**: Execute one task at a time from approved tasks.md.
**Prerequisites**: All previous documents approved.
**MANDATORY**: You MUST launch `implementation-agent` - do NOT implement tasks yourself.
**Process**:
1. Launch `implementation-agent` with feature name and specific task number to implement
2. Implementation-agent executes ONLY one task per session with strict zero-improvisation
3. Review completed task with user
4. After approval, suggest new session for next task (launch agent again for next task)
**Implementation-agent handles**:
- Pre-implementation verification (reading specs, checking resources, clarifying ambiguities)
- Strict adherence to specifications without improvisation
- Requesting approval for any unclear visual/design elements
- Using MCP servers for external resources (Jira, Confluence, GitHub, Figma)
- Marking tasks as completed in tasks.md
- One task per session enforcement
## Core Principles
1. **Sequential Execution**: Complete phases in order
2. **Explicit Approval**: Never advance without clear user confirmation
3. **Iterative Refinement**: Continue revision cycles until approval
4. **Incremental Building**: Each phase builds on the previous
5. **Zero Improvisation**: During implementation, follow specs exactly
## Your Role
- Coordinate phase transitions and launch appropriate subagents (requirements-agent, tech-design-agent, tasks-agent, implementation-agent)
- Enforce approval gates - never assume satisfaction
- Verify document quality before proceeding
- Handle revision requests by re-launching subagents with feedback
- Communicate progress and next steps clearly
- Stop after tasks approval unless implementation explicitly requested
- For implementation phase, always launch implementation-agent (never implement tasks directly)
## Verification Checklist (Before Each Phase)
Before starting a phase, verify:
- ✅ Am I about to launch a subagent? (YES = correct, NO = STOP and launch agent)
- ✅ Am I about to use Task tool? (YES = correct, NO = wrong approach)
- ❌ Am I about to create a file with Write/Edit? (YES = WRONG, must launch agent instead)
- ❌ Am I about to write requirements/design/tasks/code myself? (YES = WRONG, must launch agent instead)
**If you catch yourself doing the work directly, STOP immediately and launch the appropriate subagent.**
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · NikiforovAll/claude-code-rules | 90 | Apache-2.0 |
| matteocodogno/wellforge | 100 | MIT |
| matteocodogno/wellforge | 100 | MIT |
| OutlineDriven/outline-driven-development | 100 | Apache-2.0 |
| agencia-conversion/agentic-seo-skills | 100 | MIT |
| gosuda/dalcom-skills | 90 | Apache-2.0 |
Database snapshot: 13.11.2026 · package version 7d9eabb4f1d2 (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
- 100spec-coder
Structured spec-first development workflow with multi-role expert review gates: clarify requirements, author spec documents (requirements/design/tasks), generate code from spec, verify with real tests, and iterate while keeping spec and code in sync. Use when user wants to build… - 100ai-dev-workflow
AIDevWorkflow: structured, spec-driven development with approval gates and persistent cross-agent task records (discovery, dependencies, specification, spec approval, planning, plan approval, implementation, testing, fixing, audit, final report). Use only when the user… - 90spec-driven-development
Plan, implement, or review spec driven development work in an existing codebase with compatibility, security, and verification controls. Use when the user explicitly requests spec driven development work. - 100spec-workflow
This skill should be used when the user asks to "build a feature", "create a spec", "start spec-driven development", "run research phase", "generate requirements", "create design", "plan tasks", "implement spec", "check spec status", "triage a feature", "create an epic",… - 90sdd
Implements the Spec-Driven Development lifecycle (Intent, Requirements, Design, Tasks, Build) for structured feature development. Use when the user wants to scaffold a new feature spec, generate EARS requirements, create a technical design, break work into tasks, or check spec… - 100spec-driven-development
A Rails-focused spec-driven development workflow for building features with AI agents. Use this skill when users want to plan features, write specs, create task breakdowns, or generate implementation prompts for Rails apps. Triggers on "sdd", "spec-driven", "shape spec", "create…