Tdd executor

Runs red/green/refactor loops against acceptance criteria and TEST_STRATEGY. Use when practicing TDD or when tests should lead implementation. Emits TDD_SESSION. Never skips red, never refactors on red, never claims green without command evidence.From its SKILL.md

Install

npx -y skills add willianbs/skills --skill tdd-executor

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

0 stars0 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

SKILL.md

2.8 KB, 596 tokens by cl100k_base, as published. Nobody here has run it

Purpose

Implement behavior test-first with a disciplined red → green → refactor loop tied to AC IDs.

When to Use / When NOT to Use

Use when: user asks for TDD; high-correctness units; pairing with TEST_STRATEGY; implementing pure logic/API contracts.

Do not use when: spike/prototype explicitly throwaway; pure docs; exploratory defect triage (defect-analyst first).

Preconditions

At least one testable AC or behavior statement. Prefer TEST_STRATEGY + TASK_GRAPH. Project test command discoverable.

Inputs / Outputs

Inputs: AC IDs, TEST_STRATEGY, CONTEXT_PACK, task scope.

Outputs: TDD_SESSION (+ code/tests); may produce/update IMPL_REPORT fields.

Upstream / Downstream

Upstream: test-strategy-designer, delivery-planner, spec-validator.

Downstream: feature-implementer (if continuing), code-reviewer, quality-gate.

Core Principles

Red before implementation for the vertical under test.
Green: minimal code to pass.
Refactor only on green; keep tests green.
One failing behavior at a time.
Behavior-focused tests; avoid testing privates unless necessary.
Record exact commands and outcomes.
Stop if AC is untestable — hand back to spec-validator.

Process

For each AC/slice:

Red — write failing test; run; capture failure.
Green — minimal implementation; run; capture pass.
Refactor — clean structure; run; stay green.
Update TDD_SESSION log per cycle.
After cycles, summarize coverage vs AC IDs; note gaps.

Lite

Single function/bugfix: one red/green cycle + optional refactor.

Evidence Requirements

commands_run with fail then pass. No “should pass” without running.

Stop Conditions / Failure Modes

Condition	Action
Cannot get a failing test (already green)	Revisit AC / test design
Untestable AC	Hand off spec-validator
Refactor breaks tests	Fix before continuing

Severity + Confidence

N/A primarily; residual risk if ACs unverified.

Output Contract

## TDD_SESSION
AC focus: ...
Cycles:
  - red: command/result
  - green: command/result
  - refactor: command/result
Remaining gaps: ...
Decision: Proceed | ProceedWithConditions | Revise | Block

Handoffs

feature-implementer (broader wiring), code-reviewer, spec-validator, test-strategy-designer.

Never

Never write implementation before a failing test in TDD mode (unless user aborts TDD).
Never refactor on red.
Never invent green test results.

What ships with it: 1 file

769 B alongside SKILL.md

README.md769 B