Execute Disciplined TDD Cycles

The skill executes a comprehensive Test-Driven Development workflow through coordinated agent orchestration, enforcing strict red-green-refactor discipline across six phases and twelve steps, each delegated to a named subagent type via the Task tool. Phase 1 (Test Specification and Design) uses comprehensive-review::architect-review to analyze requirements and define acceptance criteria and edge cases, then unit-testing::test-automator to design the test architecture, fixtures, and mocks. Phase 2 (RED) has unit-testing::test-automator write failing unit tests without production code, gated by tdd-workflows::code-reviewer verifying every test fails for the right reason. Phase 3 (GREEN) has backend-development::backend-architect write the minimal implementation needed to pass, gated by unit-testing::test-automator confirming all tests pass and no existing test broke. Phase 4 (REFACTOR) has tdd-workflows::code-reviewer apply SOLID principles and remove duplication while tests stay green, then unit-testing::test-automator refactor the tests themselves without losing coverage. Phase 5 adds failing-first integration tests followed by integration implementation. Phase 6 adds performance and edge-case tests, then a final comprehensive review checking that the TDD process was actually followed.

Configuration sets minimum line coverage at 80%, branch coverage at 75%, and critical-path coverage at 100%, with refactoring triggered by cyclomatic complexity over 10, methods over 20 lines, classes over 200 lines, or duplicate blocks over 3 lines. An --incremental flag switches to one-test-at-a-time development (write one failing test, make only that one pass, refactor, repeat); a --suite flag switches to batch mode (write all tests for a feature, implement to pass all of them, refactor the whole module, then add integration tests). Each phase has its own validation checklist (for example RED requires all tests to fail with meaningful error messages before implementation, and GREEN forbids any code beyond what the tests require), and the workflow tracks time per phase, cycle count, coverage progression, refactoring frequency, and defect-escape rate. If TDD discipline is broken the workflow stops immediately, identifies the violated phase, rolls back to the last valid state, and documents the lesson learned. Seven anti-patterns are flagged explicitly (implementation before tests, tests that already pass, skipping refactor, tests written after implementation, and others), and success is defined as 100% test-first code, continuous passing tests, coverage above threshold, and unit tests running in under 5 seconds.

Use it when a feature or module needs to be built with enforced test-first discipline rather than tests added after the fact. It is not a substitute for environment-specific validation, testing, or expert review, and it stops for clarification when required inputs, permissions, safety boundaries, or success criteria are missing.

Input is the feature or module requirements. Output is a test specification and edge-case matrix, a failing-then-passing unit and integration test suite, a refactored implementation meeting the coverage thresholds, and a final review report confirming the TDD process was followed.

Teams and agents that need enforced red-green-refactor discipline with hard coverage gates and phase validation, rather than a loosely-followed TDD suggestion.