Skip to content
Skills Library
Programming · Building & coding

implement-tdd

/implement-tdd

Use to implement a .NET/DDD batch or a whole plan under strict TDD: launches the run-lot workflow (run-plan for a plan) and relays its report.

Licence
MIT
Last repository change
27.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
8
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use to implement a .NET/DDD batch or a whole plan under strict TDD: launches the run-lot workflow (run-plan for a plan) and relays its report.

Arguments

/implement-tdd [batch FX <global plan path> | <global plan path> | batch FX — correction: manual finding]
Original author description

Use to implement a .NET/DDD batch or a whole plan under strict TDD: launches the run-lot workflow (run-plan for a plan) and relays its report.

How it works

  1. When
  2. Launch
  3. During the run
  4. End
Original SKILL.md headings · 32 lines, 510 words
SKILL.md preview
---
name: implement-tdd
description: "Use to implement a .NET/DDD batch or a whole plan under strict TDD: launches the run-lot workflow (run-plan for a plan) and relays its report."
argument-hint: "[batch FX <global plan path> | <global plan path> | batch FX — correction: manual finding]"
---

# Strict TDD — launch the chain

The TDD chain is the `run-lot` workflow (`workflows/run-lot.js`, shipped by the plugin): cycles read from the sheet's `## Cycles` block (design only when absent), one `tdd-cycle` agent per cycle — RED, a checkpoint the TDD scope hook checks on the tree, then GREEN + REFACTOR + COST + handler `CLAUDE.md` —, global green beside the pre-audit gate (a haiku agent runs what `cctoolkit suites-plan` resolves, a repair agent opens only on a red suite), audit (`ddd-tdd-auditor`). A batch whose files touch no authorisation, migration nor public contract closes `light` (`cctoolkit closing-level`): one review of the diff on Correctness and Scope instead of the audit; the next sheet is never reviewed by the run, its own design checks it; the report's `Closing:` line says which and why. The script holds the sequence; agent definitions, `.claude/rules/*.md` and `references/` hold the method. Never run the chain by hand, never commit by hand: the workflow commits each `DONE` batch itself (`cctoolkit batch-baseline commit`).

$ARGUMENTS

## When

- Validated plan from `/plan-implementation`, batch sheet `todo/<code>/<CODE>-PLAN-FX.md` present → this skill.
- No plan → no code: route to `/plan-implementation`.
- `/effort medium` before launching (`hooks/implement-tdd-guard.sh` refuses `high`).

## Launch

- **`batch FX <global plan path>`** → sheet = `<plan without .md>-FX.md`; Skill `cctoolkit:run-lot`, argument = that sheet path as text (never an `@` mention).
- **`<global plan path>`** alone, or "the whole plan" → Skill `cctoolkit:run-plan`, argument = the plan path, optionally `--until FX` / `--only FX`.
- No path → `ls todo/*/*-PLAN.md`; several → ask.
- **`batch FX — correction: manual finding`** → one `Edit` of the sheet: a new cycle in its `## Cycles` block (`behaviour` = `Correction Cn — [finding]`, wave after the last, contract fields per `references/design.md`), then `cctoolkit sheet-cycles <sheet> --index` exit 0. Sheet without the block → sub-step `Correction Cn — [finding]` under the affected step, the run's design writes the block. Finding changing scope, an RM/CU or a design decision → stop, `/business-spec` or `/plan-implementation`. Then launch `run-lot` on the sheet.

Before launching: `cctoolkit plan-next-batch <plan> --outside FX` exit 0, `cctoolkit doctor` without FAIL, test containers reachable when the batch touches Infrastructure.

## During the run

The run never asks nor waits: an ambiguity is decided by the agent that meets it and listed under `## To validate`; what no retry settles ends the batch at once, `BLOCKED`. Never resume it (`resumeFromRunId`): launch a new run, the saved cycles are not redone.

## End

Relay the workflow result: status, reason, verdict, report path (`run/batches/FX.md`; for a plan, `run/<stamp>.md`, its `## To validate` first: the decisions taken without the user, to read after the plan). A plan result carrying `merge` → say its `state` and lines, then Skill `cctoolkit:knowledge-merge` with the plan path: it shows the diff and writes the base on the user's confirmation only. `BLOCKED` → fix the cause, record `Hn` marked `user decision` in the sheet, launch a new run.

Batch run `DONE` → end with `→ Batch FX complete — manual validation required. Run /clear before any other batch.`
Files in this package (8)
  • SKILL.md 4 KB
  • references/claude-md-handler.md 4 KB
  • references/closing.md 3 KB
  • references/common-rules.md 9 KB
  • references/conventions.md 2 KB
  • references/design.md 8 KB
  • references/parallelism.md 3 KB
  • references/test-scope.md 11 KB

Versions

The database has no other skills named implement-tdd.

Database snapshot: 13.11.2026 · package version 7720bacca50c (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100spec-implement
    Continue an approved Spec-backed workflow when the user says "implement", "go", "start", or "do it". After Codex Plan Mode, persist the next missing design.md or plan.json artifact and stop. When both artifacts exist, execute plan.json with TDD and report between batches.
  • 90workflow-tdd-plan-plan
    Unified TDD workflow skill combining 6-phase TDD planning with Red-Green-Refactor task chain generation, and 4-phase TDD verification with compliance reporting. Triggers on "workflow-tdd-plan", "workflow-tdd-verify".
  • 100tdd-workflow
    Implement features using TDD workflow with requirements-first approach. Use when implementing new features, adding functionality, or when user asks to build something.
  • 95ddd.work
    TDD 開發執行:coordinator 逐 milestone 派 ddd-developer 以 Red → Green → Refactor 循環實作並驗收; 遇到 🔀 平行工作線時同時派發多個 worker 分工。 spec.md 已確認、準備寫程式碼時使用。 Trigger: "start implementing", "begin development", "let's code", "do TDD", "開始實作", "開始寫", "動工", /ddd.work。
  • 100tdd-implement
    Implement a feature or fix a bug using strict TDD. Analyzes the requirement, creates tests first, implements minimal code, then refactors. Use for feature requests, bug fixes, or enhancements that need test coverage.
  • 100workflow-build-feature
    Build a feature end to end: spec and TDD, implement, unit tests, Playwright check, PR. Use when "build a feature" or "implement this end-to-end". Spec/TDD loop only → workflow-spec-tdd. One bug → workflow-fix-and-ship.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.