Tdd+

tdd+ — Disciplined Implementation

Wraps superpowers:test-driven-development. Requires superpowers to be installed.

This skill activates tdd+ phase in the enforcement layer. During this phase:

• Full test suite runs are redirected (use scoped tests only)
• Stale test warnings fire when source edits lack test updates
• Active enforcement rules from session context are enforced (see session-start output; real dependencies in stack/E2E (integration-layer) tests by default)

Procedure

Phase A: Setup

1. Announce phase entry:

``` Now using tdd+ skill. Enforcement layer active:

• Test scope: scoped runs only (full suite reserved for verify+)
• Stale tests: warnings when source edited without test updates
• Zero-defect: every failure must be fixed before proceeding

```

1. Load the plan from docs/plans/.

1. Identify the task(s) to implement.

1. If branch discipline is active (see session-start output) and you are on a

protected branch, create an isolated workspace before implementing — a worktree (superpowers:using-git-worktrees) when the plan is multi-task or the working tree is dirty, a plain feature branch otherwise.

Phase B: Implement Each Task (delegate to superpowers:test-driven-development)

1. For each task in the plan, follow RED-GREEN-REFACTOR:

RED — Write the failing test first:

• Write a test that captures the task's requirement
• Use full-loop assertions where applicable:
• Primary: does the function return the expected value?
• Second-order: did the side effect occur? (state change, log entry, event)
• Third-order: is the system still consistent? (no orphan records, no leaked connections)
• If the plan defines a signal stack, each task's completion gate is its

named gating signal — run that signal and show its output before marking the task done

• Run the test: it MUST fail (if it passes immediately, the test is wrong)
• Show the failure output

GREEN — Write minimal code to make the test pass:

• Write the smallest possible implementation
• Do not add features not in the plan
• Run the scoped test: npx vitest run tests/path/to/specific.test.ts
• Show the passing output

REFACTOR — Clean up while tests pass:

• Improve code structure without changing behavior
• Run scoped tests after each refactoring step
• Commit after each completed task

1. After each source file edit, check:

• Was the corresponding test file also updated?
• If not, the enforcement layer will emit a stale test warning
• Address it before proceeding to the next task

Phase C: Task Completion

1. After each task, verify:

• [ ] Test was written first and shown to fail
• [ ] Implementation makes the test pass
• [ ] Scoped test run passes (not full suite)
• [ ] Active enforcement rules followed (see session-start output)
• [ ] Commit made with descriptive message

1. Proceed to next task or exit tdd+ phase when all plan tasks complete.

Test Scope Rules

During tdd+ phase, the enforcement layer redirects:

• npx vitest run (full suite) → advise to run scoped tests only
• pytest (full suite) → advise to run specific test file

Use scoped commands:

npx vitest run tests/router/resolver.test.ts
pytest tests/test_config.py::test_load_config

Full suite runs happen during verify+ phase, not here.

Skill Chain

After completing all plan tasks with tdd+:

• Invoke /verify+ to run full suite and verify against plan acceptance criteria

Completion

Report one of these states when the skill finishes:

• DONE — All plan tasks implemented with passing scoped tests. No constitutional violations.
• DONEWITHCONCERNS — All tasks implemented but some tests need attention or minor deviations exist.
• BLOCKED — Tests failing, cannot proceed without fixing. Return to RED phase.
• NEEDS_CONTEXT — Need user input to resolve an implementation ambiguity or design question.

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: franklywatson
• Source: franklywatson/claude-rig
• License: MIT

Install and usage instructions live in the source repository linked above.