Plugin Ecosystem

spec-kit

Spec Driven Development toolkit — structured specification, planning, and implementation workflows.

New

Spec Driven Development toolkit — structured specification, planning, and implementation workflows for systematic feature development.

Source: claude-night-market marketplace Version: 1.4.3 Author: Alex Thola

Key Commands

Command	Description	When to Use
`/speckit-startup`	Bootstrap the spec-driven development workflow at the start of a session	At the beginning of a new feature or project
`/speckit-specify`	Create or update the feature specification from a natural language description	When defining requirements for a feature
`/speckit-clarify`	Clarify specification requirements through interactive Q&A	When the spec has ambiguities or gaps
`/speckit-plan`	Generate an implementation plan from the specification	After the spec is finalized
`/speckit-tasks`	Generate dependency-ordered tasks from the plan	After the plan is approved
`/speckit-implement`	Execute all tasks defined in the task list	When ready to implement
`/speckit-analyze`	Analyze specification coverage and completeness	When auditing spec quality
`/speckit-checklist`	Generate a spec completion checklist	When tracking spec progress
`/speckit-constitution`	Define a project constitution (principles and constraints)	When establishing project ground rules

Skill	When It Activates
speckit-orchestrator	When orchestrating the full spec-driven workflow
spec-writing	When writing or refining specifications
task-planning	When generating and ordering implementation tasks

Agent	Purpose
spec-analyzer	Analyze specification coverage, gaps, and quality
task-generator	Generate dependency-ordered tasks from design artifacts
implementation-executor	Execute implementation tasks systematically

The full spec-kit pipeline from idea to implementation:

Bootstrap — Run /speckit-startup to initialize the workflow. This sets up the project context and any constitution (principles and constraints).
Specify — Run /speckit-specify and describe the feature in natural language. Spec-kit produces a structured specification document covering requirements, acceptance criteria, and edge cases.
Clarify — Run /speckit-clarify if there are ambiguities. This launches an interactive Q&A that refines the spec until all questions are resolved.
Plan — Run /speckit-plan to generate an implementation plan from the finalized spec. The plan includes architecture decisions, file changes, and testing strategy.
Generate tasks — Run /speckit-tasks to produce a dependency-ordered task list. Each task has clear inputs, outputs, and acceptance criteria.
Implement — Run /speckit-implement to execute the tasks. The implementation-executor agent works through each task systematically, respecting dependency order.

When you want to verify a specification is complete:

Analyze — Run /speckit-analyze to assess specification coverage. The spec-analyzer agent identifies gaps, ambiguities, and missing edge cases.
Checklist — Run /speckit-checklist to generate a completion checklist tracking which parts of the spec are fully defined.

The spec-kit pipeline is sequential by design: specify, then plan, then tasks, then implement. Skipping steps produces lower-quality results.
/speckit-constitution is optional but valuable for long-running projects. It defines principles (like "prefer simplicity" or "all APIs must be versioned") that guide all subsequent specs.
Spec-kit pairs well with superpowers. Use spec-kit for the specification phase, then superpowers' /execute-plan for implementation with TDD and code review checkpoints.
The task dependency ordering in /speckit-tasks ensures you build foundations before features that depend on them.