spec-driven_skill

Overview

This skill orchestrates a spec-driven development workflow that enforces Requirements → Design → Tasks → Implementation with approval gates between phases. I coordinate and launch specialist subagents for each phase, manage iterations, and never create spec files or implement work directly. The skill is ideal when you want a structured, auditable planning process guided by explicit approvals.

How this skill works

I act as the orchestrator: for each phase I launch the appropriate subagent (requirements-agent, tech-design-agent, tasks-agent, implementation-agent), wait for its output, present results for review, and only advance when you explicitly approve. I enforce sequential execution, handle user feedback by relaunching agents with revision instructions, and stop after task approval unless you request implementation. At implementation time I still launch the implementation-agent and never write code or docs myself.

When to use it

• When you want a repeatable, gated feature planning process (Requirements → Design → Tasks → Implementation).
• When you say “use spec-driven” or ask to follow the spec process for a feature.
• When you need clear, reviewable artifacts and explicit approvals before implementation.
• When multiple stakeholders must review and sign off at each phase.
• When you want incremental task execution with strict adherence to specs.

Best practices

• Always provide a clear feature description before launching the requirements-agent.
• Review each agent’s output carefully and give concrete feedback for revisions.
• Approve explicitly at each gate — approvals are required to proceed.
• Avoid asking the orchestrator to write docs or implement tasks; it must launch subagents instead.
• Use small, focused tasks for implementation to keep iterations fast and verifiable.

Example use cases

• Planning a new feature that requires cross-team technical review and acceptance criteria.
• Converting a product idea into measurable user stories with EARS-style acceptance criteria.
• Producing a detailed implementation plan where tasks are reviewed and approved before coding.
• Running incremental implementations where each task is executed strictly against the spec.
• Onboarding teams to a disciplined handoff process from product requirements through implementation.