SkillAgentSearch skills...

speckit-workflow

Comprehensive understanding of the spec-kit methodology. Constitution-driven feature development with specify, plan, tasks, and implement phases.

Install / Use

npx skills add tzachbon/smart-ralph --skill speckit-workflow

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

88/100

Category

Automation

Supported Platforms

Universal

Our assessment of speckit-workflow

speckit-workflow scores 88/100 on our quality scale, 1574th of 2,768 Automation skills we index.

Its SKILL.md is 7.5 KB long, well organised into 24 sections with 3 code examples: a thorough specification that gives an agent plenty to work with.

It has 550 GitHub stars, a meaningful sign that others use it.

Substance
29/30
Structure
18/20
Description
15/15
Adoption
12/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated about 2 months ago, so speckit-workflow is actively maintained.
  • Our last check on 2026-11-01 found the source still online.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-04. Automated pattern scan on 2026-10-04. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

speckit-workflow compared with similar skills

All 4 of these similar skills score higher than speckit-workflow; compare them before choosing.

SkillScoreStarsUpdatedFormat
speckit-workflow (this skill)by tzachbon885502mo agoSKILL.md
taste-skillby Leonxlnx100118.3k10d agoCLAUDE.md
Agent-Reachby Panniantong100113.0k10d agoCLAUDE.md
rufloby ruvnet10082.0ktodayCLAUDE.md
Claude-Code-Game-Studiosby Donchitos10040.1k9d agoCLAUDE.md

Frequently asked questions

How do I install speckit-workflow?
Run npx skills add tzachbon/smart-ralph --skill speckit-workflow. The install tabs above show the steps for each supported agent.
Which AI agents does speckit-workflow work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is speckit-workflow safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is speckit-workflow still maintained?
The repository was last updated about 2 months ago, so speckit-workflow is actively maintained.

name: speckit-workflow description: Comprehensive understanding of the spec-kit methodology. Constitution-driven feature development with specify, plan, tasks, and implement phases. version: 0.1.0

SpecKit Workflow

The SpecKit methodology is a constitution-driven approach to feature development. It ensures consistency across features by grounding all decisions in project principles.

Core Philosophy

Constitution First: Every feature is designed against the project's constitution - a living document of principles, constraints, and standards.

Governance Over Convention: Rather than implicit patterns, SpecKit makes governance explicit through:

  • Constitution principles (MUST, SHOULD, MAY)
  • Feature specifications tied to principles
  • Quality checklists as "unit tests for requirements"
  • Consistency analysis across artifacts

Directory Structure

.specify/
├── memory/
│   └── constitution.md       # Project principles and standards
├── .current-feature          # Active feature pointer
├── templates/                # Artifact templates
│   ├── spec-template.md
│   ├── plan-template.md
│   ├── tasks-template.md
│   └── checklist-template.md
└── specs/
    └── <id>-<name>/          # Feature directories
        ├── .speckit-state.json
        ├── .progress.md
        ├── .coordinator-prompt.md
        ├── spec.md           # Feature specification
        ├── plan.md           # Technical design
        ├── tasks.md          # Implementation tasks
        ├── research.md       # Research findings (optional)
        ├── data-model.md     # Entity definitions (optional)
        ├── contracts/        # API contracts (optional)
        └── checklists/       # Quality checklists

Feature ID System

Features use auto-incremented 3-digit IDs:

  • 001-user-auth
  • 002-payment-gateway
  • 003-notification-system

Benefits:

  • Natural ordering in filesystem
  • Easy reference in commits/PRs
  • Prevents naming conflicts

Workflow Phases

Phase 1: Constitution (/speckit:constitution)

Establish or update project-wide principles.

Inputs: Project context, team preferences Outputs: .specify/memory/constitution.md

Constitution sections:

  • Identity: Project name, purpose, core domain
  • Principles: MUST/SHOULD/MAY rules
  • Technology Stack: Languages, frameworks, tools
  • Patterns: Architecture, naming, error handling
  • Quality Standards: Testing, performance, security

Phase 2: Specify (/speckit:specify)

Define the feature specification against constitution.

Inputs: Feature goal, constitution reference Outputs: spec.md

Specification contains:

  • Feature overview and goals
  • User stories with acceptance criteria
  • Constitution alignment markers
  • Out of scope items
  • Dependencies and risks

Phase 3: Clarify (/speckit:clarify) - Optional

Resolve ambiguities through structured Q&A.

Inputs: spec.md with ambiguities Outputs: Updated spec.md with clarifications

Rules:

  • Maximum 5 clarifying questions per session
  • Each question has 2-4 options + "Other"
  • Recommendations marked when applicable
  • Clarifications appended to spec

Phase 4: Plan (/speckit:plan)

Generate technical design from specification.

Inputs: spec.md, constitution, codebase context Outputs: plan.md, optionally data-model.md, contracts/

Plan contains:

  • Architecture overview
  • Component breakdown
  • Data flow diagrams
  • API contracts
  • Integration points
  • Risk mitigation

Phase 5: Tasks (/speckit:tasks)

Break plan into dependency-ordered implementation tasks.

Inputs: plan.md, spec.md Outputs: tasks.md

Task format:

- [ ] T001 [P] [US1] Task description `path/to/file.ts`

Components:

  • T001: Sequential task ID
  • [P]: Parallel marker (optional)
  • [US1]: User story reference (optional)
  • Description with file path

Task phases:

  1. Setup: Environment, dependencies, scaffolding
  2. Core: Main implementation tasks
  3. Integration: Connect components
  4. Polish: Error handling, edge cases
  5. Verification: Quality checkpoints

Phase 6: Implement (/speckit:implement)

Execute tasks via Ralph Wiggum loop.

Inputs: tasks.md, state file Outputs: Code changes, commits, updated progress

Execution model:

  • Coordinator reads state, delegates to executor
  • 4-layer verification before advancing
  • Parallel execution for [P] marked tasks
  • Fresh context per task

State Management

State File (.speckit-state.json)

{
  "featureId": "001",
  "name": "user-auth",
  "basePath": ".specify/specs/001-user-auth",
  "phase": "execution",
  "taskIndex": 0,
  "totalTasks": 15,
  "taskIteration": 1,
  "maxTaskIterations": 5,
  "globalIteration": 1,
  "maxGlobalIterations": 100,
  "awaitingApproval": false
}

Progress File (.progress.md)

Tracks:

  • Completed tasks with commit hashes
  • Learnings and context for future tasks
  • Blockers and resolutions
  • Cross-task dependencies

Quality Assurance

Checklists (/speckit:checklist)

Domain-specific quality checklists:

  • UX checklist
  • API checklist
  • Security checklist
  • Performance checklist
  • Accessibility checklist

Checklists are "unit tests for requirements" - verifiable criteria before implementation.

Analyze (/speckit:analyze)

Cross-artifact consistency analysis:

  • Spec ↔ Constitution alignment
  • Plan ↔ Spec coverage
  • Tasks ↔ Plan traceability
  • Identifies gaps, conflicts, ambiguities

Command Reference

| Command | Purpose | Phase | |---------|---------|-------| | /speckit:start <name> | Create or resume feature | Entry | | /speckit:constitution | Create/update project principles | 1 | | /speckit:specify | Define feature specification | 2 | | /speckit:clarify | Resolve spec ambiguities | 3 | | /speckit:plan | Generate technical design | 4 | | /speckit:tasks | Break plan into tasks | 5 | | /speckit:implement | Execute tasks | 6 | | /speckit:analyze | Check consistency | Any | | /speckit:checklist | Generate quality checklist | Any | | /speckit:status | Show current state | Any | | /speckit:switch <id> | Change active feature | Any | | /speckit:cancel | Stop execution, cleanup | Any |

Agent Ecosystem

| Agent | Purpose | Used By | |-------|---------|---------| | constitution-architect | Create/update constitution | constitution | | spec-analyst | Generate specifications | specify | | plan-architect | Technical design | plan | | task-planner | Task breakdown | tasks | | spec-executor | Execute single task | implement | | qa-engineer | Verification tasks | implement |

Constitution Integration

All phases reference the constitution:

  1. Specify: Maps features to constitution principles
  2. Plan: Architecture follows constitution patterns
  3. Tasks: Quality checkpoints enforce constitution
  4. Implement: Executor validates against standards

Constitution markers in artifacts:

  • [C§3.1]: References constitution section 3.1
  • [MUST]: Required by constitution
  • [SHOULD]: Recommended by constitution
  • [MAY]: Optional per constitution

Best Practices

Starting New Features

  1. Ensure constitution exists and is current
  2. Use descriptive feature names (kebab-case)
  3. Include clear success criteria in spec
  4. Reference related features if applicable

During Implementation

  1. Follow task order (dependencies matter)
  2. Commit after each task
  3. Update progress with learnings
  4. Run verification checkpoints

Maintaining Constitution

  1. Version constitution changes semantically
  2. Run sync impact analysis after updates
  3. Update affected features if needed
  4. Document rationale for changes

Related Skills

View on GitHub
GitHub Stars550
CategoryAutomation
Updated2mo ago
Forks48

Languages

Shell

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions