Facilitates the ATDD cycle from requirements analysis through to spec implementation and verification.

Install

mkdir -p .claude/skills/atdd && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/10768" && unzip -o skill.zip -d .claude/skills/atdd && rm skill.zip

Installs to .claude/skills/atdd

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Spec-Driven ATDD workflow skill. Use for running the full ATDD cycle, writing Gherkin feature files, creating technical specs, generating acceptance tests, or reviewing spec compliance. Trigger phrases: ATDD, BDD, Gherkin, spec-first, acceptance test, feature file, Given When Then, red-green-refactor, spec coverage, write scenarios.
334 chars✓ has a “when” triggerlonger than Claude Code's old 250-char listing cap (fine on current versions)
Advanced

Key capabilities

  • Write Gherkin feature files
  • Generate test stubs
  • Run quality gates
  • Verify spec compliance

How it works

It manages the full ATDD cycle by enforcing a spec-first approach, generating test stubs, and running quality gates to ensure implementation matches the spec.

Inputs & outputs

You give it
Feature requirement
You get back
Failing test stubs or passing implementation

When to use atdd

  • Convert requirements to Gherkin
  • Write acceptance tests
  • Verify spec compliance

About this skill

ATDD — Acceptance Test-Driven Development

When to Use

  • Starting a new feature (write specs before any code)
  • Converting requirements to Gherkin scenarios
  • Generating acceptance test stubs from a spec
  • Implementing code to pass failing tests
  • Verifying spec compliance after implementation
  • Running the full automated ATDD cycle end-to-end

Workflow

Analyze → Spec → Tests (Red) → Implementation (Green) → Quality Gates → Refactor → Spec & Doc Sync → PR

Quick Commands

CommandPurpose
/analyze-projectDetect language, frameworks, tools, AND code conventions; write project profile
/write-specGenerate Gherkin + technical spec from requirements
/write-acceptance-testsGenerate failing test stubs from a spec file
/implement-from-specImplement code to make failing tests pass (re-reads project profile first)
/run-quality-gatesRun lint, format, typecheck, build, test — iterate until green
/refactor-passing-testsSafe refactor after all tests are green
/verify-spec-coverageHard spec & doc sync gate — repairs spec/README/profile drift in-place
/create-pull-requestCreate branch, commit, push, open PR
/address-review-commentsHandle PR review feedback, update spec if needed
@atdd-cycleFull automated cycle (analyze → spec → tests → implement → gates → sync → PR)
@spec-writerDedicated spec writing agent
@spec-reviewerDedicated spec & doc compliance review agent

Templates & References

Core Principles

  1. Spec is the source of truth — change spec first, then tests, then code
  2. Red before green — never implement without a confirmed-failing test
  3. Minimum viable implementation — only write code that a failing test demands
  4. Behavior, not implementation — specs describe observable outcomes, not internal mechanics
  5. Mirror the codebase — Phase 3 re-reads docs/project-profile.md and follows the conventions already in use
  6. Sync or stop — Phase 6 (Spec & Doc Sync) is a hard gate; the cycle is not done while the spec, README, or project profile drift from what the code does

Profile Bootstrap (First Action)

If docs/project-profile.md does not exist, your first action is /analyze-project — even for ad-hoc requests. Tell the user: "No project profile found — running Phase 0 first so I have an accurate picture of this codebase's tooling and conventions."

Cycle — Pointer

Analyze → Spec → Tests (Red) → Implement (Green) → Quality Gates → Refactor → Spec & Doc Sync → PR

Full procedure: docs/atdd/workflow.md (authoritative).

Per-phase prompt mapping:

PhaseTriggerKey output / gate
0/analyze-projectdocs/project-profile.md with Tooling, Conventions, Sources consulted
1/write-spec / @spec-writerspecs/features/*.feature + specs/technical/*-spec.md — USER GATE
2/write-acceptance-testsAll scenarios have failing stubs; "all red ✓" reported
3/implement-from-specMinimum code, mirror profile, @smoke first
4/run-quality-gateslint / format / typecheck / build / test all pass
5/refactor-passing-testsStructure only, tests stay green
6/verify-spec-coverage / @spec-reviewerNo spec/README/profile drift (hard gate)
7/create-pull-requestBranch, commit, push, PR

Spec Directory Layout

specs/
├── features/          # Gherkin .feature files
│   └── *.feature
└── technical/         # Markdown technical specs
    └── *-spec.md

When not to use it

  • When the project does not follow ATDD
  • When the task is not spec-driven

Prerequisites

docs/project-profile.md

Limitations

  • Requires project profile bootstrap
  • Spec-doc drift prevents cycle completion

How it compares

It enforces a strict red-green-refactor cycle and requires spec-doc synchronization as a hard gate.

Compared to similar skills

atdd side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
atdd (this skill)01moNo flagsAdvanced
code-review-checklist324dNo flagsBeginner
openspec-verify-change36moReviewAdvanced
superpowers-finish16moNo flagsBeginner

Try saying

Example prompts that trigger this skill in your AI assistant.

Search skills

Search the agent skills registry