Pipeline skills reference

Pipeline skills execute sequentially to transform requirements into running code. Each skill produces artifacts consumed by the next stage.

Pipeline flow

requirements-engineer → specifications-engineer → spec-auditor →
plan-architect → task-generator → task-implementer → test-planner

requirements-engineer

Professional requirements engineering based on SWEBOK v4 Chapter 1.

Invocation

/sdd:requirements-engineer                    # Elicit mode (interactive)
/sdd:requirements-engineer --audit            # Audit mode (review existing)
/sdd:requirements-engineer --format           # Format mode (convert format)

Modes

mode

enum

default:"elicit"

Operation modeOptions:

elicit — Interactive requirements gathering
audit — Quality assessment of existing requirements
format — Convert between requirement formats

Input

input

string

Path to existing requirements document (audit/format modes only)

Output artifacts

requirements/REQUIREMENTS.md — Structured requirements in EARS format
Sections: Functional, Nonfunctional, Constraints, Traceability

EARS syntax

All requirements use Easy Approach to Requirements Syntax:

Ubiquitous

pattern

THE <system> SHALL <behavior>Example: THE system SHALL store all data encrypted at rest

Event-driven

pattern

WHEN <trigger> THE <system> SHALL <behavior>Example: WHEN a user submits login credentials THE system SHALL validate them within 2 seconds

State-driven

pattern

WHILE <state> THE <system> SHALL <behavior>Example: WHILE the system is in maintenance mode THE system SHALL reject all write operations

Unwanted

pattern

IF <condition> THEN THE <system> SHALL <behavior>Example: IF the database connection fails THEN THE system SHALL retry 3 times with exponential backoff

Quality gates

Each requirement is validated against:

Unambiguous — Single interpretation only
Testable — Concrete acceptance criteria
Atomic — Single decision per requirement
Binding — Stakeholder-confirmed necessity
True — Represents actual need, not solution

specifications-engineer

Transforms requirements into formal technical specifications.

Invocation

/sdd:specifications-engineer                          # Full generation
/sdd:specifications-engineer --analyze                # Readiness analysis
/sdd:specifications-engineer --brownfield             # From existing code

Modes

mode

enum

default:"create"

Operation modeOptions:

analyze — Analyze requirements for specification readiness
create — Generate specifications from requirements
validate — Validate existing specifications
brownfield — Incremental specification for existing code

Input

--requirements

string

default:"requirements/REQUIREMENTS.md"

Path to requirements document

Output artifacts

Generates complete spec/ directory:

spec/domain/

directory

Domain model and business rulesFiles:

01-GLOSSARY.md — Ubiquitous language
02-ENTITIES.md — Domain entities
03-VALUE-OBJECTS.md — Value objects and enums
04-STATES.md — State machines
05-INVARIANTS.md — Business invariants (INV-XXX-NNN)

spec/use-cases/

directory

Use case specificationsFormat: UC-NNN-{slug}.md per use caseSections: Actor, Preconditions, Main Flow, Alternative Flows, Exception Flows, Postconditions

spec/workflows/

directory

Multi-step process flowsFormat: WF-NNN-{slug}.md per workflow

spec/contracts/

directory

API and event contractsFiles:

API-{module}.md — REST/GraphQL contracts per module
EVENTS-{module}.md — Domain events
PERMISSIONS-MATRIX.md — RBAC matrix

spec/tests/

directory

Test specificationsFiles:

BDD-UC-NNN.md — BDD scenarios per use case
PROPERTY-TESTS.md — Property-based test specs

spec/nfr/

directory

Non-functional requirementsFiles:

PERFORMANCE.md — Performance targets (p99, throughput)
LIMITS.md — Rate limits, quotas, thresholds
SECURITY.md — Security requirements
OBSERVABILITY.md — Logging, metrics, alerting

spec/adr/

directory

Architecture Decision RecordsFormat: ADR-NNN-{slug}.md per decision

Clarification markers

When ambiguities cannot be resolved during generation:

<!-- [NEEDS CLARIFICATION] NC-001: Max file size: 10MB or 25MB? -->

Tracked in spec/CLARIFICATIONS-PENDING.md until resolved.

spec-auditor

Systematic specification quality assurance and defect detection.

Invocation

/sdd:spec-auditor                                     # Full audit
/sdd:spec-auditor --fix                               # Apply corrections
/sdd:spec-auditor --focused --scope=CHANGE-REPORT.md  # Focused audit

Modes

mode

enum

default:"audit"

Operation modeOptions:

audit — Detect specification defects
fix — Apply corrections from answered audit
focused — Audit only changed documents

Defect categories

CAT-01

category

Ambiguities — Terms admitting multiple interpretationsSignals: “appropriate”, “reasonable”, “normally”, missing quantifiers

CAT-02

category

Implicit rules — Behavior given as understood but not documentedSignals: Validations not specified, order assumed

CAT-03

category

Dangerous silences — Cases not covered causing undefined behaviorSignals: Flows without error handling, states without exit transitions

CAT-04

category

Semantic ambiguities — Same term with different meaningsSignals: Synonyms not controlled, glossary violations

CAT-05

category

Contradictions — Specifications conflicting between documentsSignals: Different values for same parameter, incompatible flows

CAT-06

category

Incomplete specifications — Missing documents or placeholder sectionsSignals: TODOs, TBD sections, empty sections

CAT-07

category

Weak invariants — Critical rules without formal invariantSignals: Restrictions in text without INV-ID, invariants without validation

CAT-08

category

Evolution risks — Designs hindering future changesSignals: Hardcoded values, closed enums, missing versioning

CAT-09

category

Missing ADRs — Architectural decisions without documentationSignals: Technologies mentioned without justification

3C verification protocol

Spec-level verification dimensions:

Completeness

dimension

Spec coverage checks

Every REQ traces to at least one spec
No orphan specs without REQ
All spec subdirectories populated
No placeholder sections remain
Traceability chain intact

Correctness

dimension

Spec-requirement alignment

Semantic match with REQ intent
No contradictions between specs
All INV codes valid
State transitions consistent
Permission alignment

Coherence

dimension

Cross-spec consistency

Glossary adherence
Terminology uniformity
Valid cross-references
Value consistency
Format consistency

Output artifacts

audits/AUDIT-BASELINE.md

file

Baseline of accepted/deferred findings

audits/AUDIT-{version}.md

file

Audit report with findings by category and severity

audits/CORRECTIONS-PLAN-{version}.md

file

(Fix mode) Corrections plan with before/after

plan-architect

Generates FASE files and implementation plans from specifications.

Invocation

/sdd:plan-architect                                   # Full generation
/sdd:plan-architect --fase 0                          # Single FASE
/sdd:plan-architect --skip-clarify                    # Skip interactive clarification
/sdd:plan-architect --regenerate-fases                # Force FASE regeneration
/sdd:plan-architect --regenerate-fases --affected=1,5 # Cascade mode

Modes

mode

enum

default:"global"

Operation scopeOptions:

global — Generate all plan artifacts
per-fase — Generate plan for single FASE
skip-clarify — Use existing clarifications
regenerate-fases — Force FASE regeneration
audit-fases — Read-only coverage check

FASE files

FASE (implementation phase) files are navigation indices mapping specs to incremental phases.

plan/fases/FASE-N-{slug}.md

file

Implementation phase indexSections:

Objetivo — What the phase enables
Criterios de Éxito — Acceptance checklist
Specs a Leer — Organized by type (UCs, ADRs, Domain, Contracts)
Invariantes Aplicables — Relevant invariants
Contratos Resultantes — Endpoints and events to implement
Verificación — Validation commands
Alcance — Incluye/Excluye boundary table

Clarification taxonomy

10 categories of implementation gaps requiring clarification:

CL-TECH

category

Technology stack — Missing language/framework choices

CL-DATA

category

Physical data model — Logical-to-physical mapping gaps

CL-ARCH

category

Architecture topology — Undefined deployment strategy

CL-SEC

category

Security implementation — Specs without library/pattern

CL-INTEG

category

Integration patterns — Undefined external protocols

CL-PERF

category

Performance strategy — NFR targets without strategy

CL-TEST

category

Test implementation — Missing test framework

CL-CICD

category

Build & deploy — Missing CI/CD definition

CL-OBS

category

Observability — Missing monitoring/logging

CL-COST

category

Cost & resources — Missing infrastructure cost estimate

Output artifacts

plan/fases/

directory

FASE navigation indicesFiles:

README.md — Coverage matrices and dependency graph
FASE-N-{slug}.md — One per implementation phase

plan/PLAN.md

file

Master implementation planSections:

Technical Context
Component Decomposition
Cross-FASE Concerns
Risk Assessment
Developer Quickstart
Validation & Traceability

plan/CLARIFY-LOG.md

file

Interactive clarification session log

plan/ARCHITECTURE.md

file

Architecture viewsViews:

C4 System Context (L1)
C4 Container Diagram (L2)
C4 Component Diagram (L3)
Deployment View
Physical Data Model
Integration Map
Security Architecture

plan/fase-plans/PLAN-FASE-N.md

file

Per-FASE implementation detailsSections:

FASE-specific technical decisions
Component implementation details
API implementation notes
Data changes (migrations)
Test strategy
Test Coverage Map (source → test mapping)

task-generator

Decomposes implementation plans into atomic, reversible tasks.

Invocation

/sdd:task-generator                                   # Full generation
/sdd:task-generator --fase 0                          # Single FASE
/sdd:task-generator --regen                           # Regenerate from scratch
/sdd:task-generator --audit                           # Validate existing tasks
/sdd:task-generator --fase=1 --incremental            # Cascade mode

Task ID convention

format

string

TASK-F{N}-{SEQ}Examples:

TASK-F0-001 — First task of FASE 0
TASK-F3-015 — 15th task of FASE 3

Task markers

[P]

marker

Parallelizable — Can execute concurrently with other [P] tasks

blocks:

annotation

Tasks that depend on this task completing

blocked-by:

annotation

Tasks that must complete before this task

[RETROACTIVE]

marker

Task documents already-implemented code (from reverse-engineer)

Source: CASCADE-{id}

annotation

Task generated by req-change cascade

Task structure

Each task entry includes:

Commit

field

Pre-generated conventional commit messageFormat: {type}({scope}): {description}Types: feat, fix, refactor, test, chore, docs, ci, perf

Acceptance

field

Concrete acceptance criteria from spec

Refs

field

Traceability references (FASE, UC, ADR, INV, REQ)

Revert

field

Revert strategy and impact assessmentCategories: SAFE, COUPLED, MIGRATION, CONFIG

Review

field

Review checklist for human reviewers

Output artifacts

task/TASK-INDEX.md

file

Global index of all tasks across all FASEs

task/TASK-ORDER.md

file

Implementation order with dependency graph and critical path

task/TASK-FASE-N.md

file

Tasks for FASE N organized by phase:

Setup — Project structure, dependencies
Foundation — Shared infrastructure
Domain — Entities, value objects, services
Contracts — API routes, handlers, events
Integration — Wiring, event handlers
Tests — Unit, integration, BDD scenarios
Verification — End-to-end validation

task-implementer

Implements code from task documents with test-first development.

Invocation

/sdd:task-implementer --fase 0                        # Implement FASE 0
/sdd:task-implementer --task TASK-F0-005              # Single task
/sdd:task-implementer --continue                      # Resume from last
/sdd:task-implementer --verify --fase 0               # Read-only verification
/sdd:task-implementer --fase 1 --new-tasks-only       # Cascade mode

Execution phases

Phase 0

phase

Context loadingLoads: CLAUDE.md, glossary, entities, states, invariants, FASE file, plan, task document

Phase 1

phase

Readiness gatesValidates: task document exists, plan exists, FASE exists, glossary exists, specs exist, git clean, tools available

Phase 2

phase

Task selection & orderingDetermines execution order respecting dependencies and [P] markers

Phase 3

phase

Pre-implementation designReads specs, extracts contracts, identifies invariants, analyzes integration

Phase 4

phase

Test-first constructionWrites failing tests for acceptance criteria, exception flows, and invariants (RED phase)

Phase 5

phase

ImplementationWrites code to pass tests (GREEN phase), then refactors (REFACTOR phase)

Phase 6

phase

Quality verificationExecutes review checklist, runs full test suite, verifies build and lint

Phase 7

phase

Atomic commit & SHA captureStages task files, commits with pre-generated message, captures SHA for traceability

Phase 8

phase

Progress trackingUpdates task checkbox, reports progress with SHA, evaluates next task

Phase 9

phase

FASE checkpoint & verificationCreates git tag, verifies Criterios de Éxito, runs full test suite, checks coverage

Pause conditions

Implementation pauses and asks user when:

PAUSE: Ambiguity

condition

Spec does not define behavior clearly

PAUSE: Decision Pending

condition

[DECISION PENDIENTE] marker found in spec

PAUSE: Spec-Implementation Conflict

condition

Spec and plan contradict

PAUSE: Build Failure

condition

Build fails after task implementation

PAUSE: Test Regression

condition

Previously passing test now fails

Implementation feedback

When spec-level issues are discovered during implementation:

feedback/IMPL-FEEDBACK-FASE-N.md

file

Spec-level issues found during implementationIssue types: AMBIGUITY, CONFLICT, MISSING-BEHAVIOR, INCORRECT-CONTRACT, STALE-DECISIONSeverities: BLOCKER, WARNINGFed to req-change for spec corrections

Output artifacts

src/**/*

directory

Implementation code following project structure

tests/**/*

directory

Unit tests, integration tests, BDD scenarios

task/TASK-FASE-N.md

file

Updated with completed task checkboxes (- [x])

feedback/IMPL-FEEDBACK-FASE-N.md

file

(if spec issues found) Spec-level feedback for req-change

Git tags

artifact

Checkpoint tags: fase-N-setup, fase-N-domain, fase-N-verified

test-planner

Generates comprehensive test plans and coverage maps.

Invocation

/sdd:test-planner                                     # Full test plan generation
/sdd:test-planner --audit                             # Gap detection only
/sdd:test-planner --fase 0                            # Single FASE scope

Output artifacts

test/TEST-PLAN.md

file

Master test planSections:

Test strategy by type (unit, integration, e2e, performance, security)
Coverage targets per FASE
Test environment requirements
Test data management
CI/CD integration

test/TEST-MATRIX-{domain}.md

file

Test coverage matrix per domain areaColumns: Requirement, Use Case, Test Type, Test File, Coverage Status

test/PERF-SCENARIOS.md

file

(if applicable) Performance test scenarios with load profiles and acceptance criteria

Skills API

MCP Tools

Artifact Schemas

​Pipeline skills reference

​Pipeline flow

​requirements-engineer

​Invocation

​Modes

​Input

​Output artifacts

​EARS syntax

​Quality gates

​specifications-engineer

​Invocation

​Modes

​Input

​Output artifacts

​Clarification markers

​spec-auditor

​Invocation

​Modes

​Defect categories

​3C verification protocol

​Output artifacts

​plan-architect

​Invocation

​Modes

​FASE files

​Clarification taxonomy

​Output artifacts

​task-generator

​Invocation

​Task ID convention

​Task markers

​Task structure

​Output artifacts

​task-implementer

​Invocation

​Execution phases

​Pause conditions

​Implementation feedback

​Output artifacts

​test-planner

​Invocation

​Output artifacts

Build docs developers (and LLMs) love

Pipeline skills reference

Pipeline flow

requirements-engineer

Invocation

Modes

Input

Output artifacts

EARS syntax

Quality gates

specifications-engineer

Invocation

Modes

Input

Output artifacts

Clarification markers

spec-auditor

Invocation

Modes

Defect categories

3C verification protocol

Output artifacts

plan-architect

Invocation

Modes

FASE files

Clarification taxonomy

Output artifacts

task-generator

Invocation

Task ID convention

Task markers

Task structure

Output artifacts

task-implementer

Invocation

Execution phases

Pause conditions

Implementation feedback

Output artifacts

test-planner

Invocation

Output artifacts