tdd-workflows-tdd-cycle

SKILL.md

Use this skill when

Working on tdd workflows tdd cycle tasks or workflows

Needing guidance, best practices, or checklists for tdd workflows tdd cycle

Do not use this skill when

The task is unrelated to tdd workflows tdd cycle

You need a different domain or tool outside this scope

Instructions

Clarify goals, constraints, and required inputs.

Apply relevant best practices and validate outcomes.

Provide actionable steps and verification.

If detailed examples are required, open resources/implementation-playbook.md.

Execute a comprehensive Test-Driven Development (TDD) workflow with strict red-green-refactor discipline:
[Extended thinking: This workflow enforces test-first development through coordinated agent orchestration. Each phase of the TDD cycle is strictly enforced with fail-first verification, incremental implementation, and continuous refactoring. The workflow supports both single test and test suite approaches with configurable coverage thresholds.]

Configuration

Coverage Thresholds

Minimum line coverage: 80%

Minimum branch coverage: 75%

Critical path coverage: 100%

Refactoring Triggers

Cyclomatic complexity > 10

Method length > 20 lines

Class length > 200 lines

Duplicate code blocks > 3 lines

Phase 1: Test Specification and Design

1. Requirements Analysis

Use Task tool with subagent_type="comprehensive-review::architect-review"

Prompt: "Analyze requirements for: $ARGUMENTS. Define acceptance criteria, identify edge cases, and create test scenarios. Output a comprehensive test specification."

Output: Test specification, acceptance criteria, edge case matrix

Validation: Ensure all requirements have corresponding test scenarios

2. Test Architecture Design

Use Task tool with subagent_type="unit-testing::test-automator"

Prompt: "Design test architecture for: $ARGUMENTS based on test specification. Define test structure, fixtures, mocks, and test data strategy. Ensure testability and maintainability."

Output: Test architecture, fixture design, mock strategy

Validation: Architecture supports isolated, fast, reliable tests

Phase 2: RED - Write Failing Tests

3. Write Unit Tests (Failing)

Use Task tool with subagent_type="unit-testing::test-automator"

Prompt: "Write FAILING unit tests for: $ARGUMENTS. Tests must fail initially. Include edge cases, error scenarios, and happy paths. DO NOT implement production code."

Output: Failing unit tests, test documentation

CRITICAL: Verify all tests fail with expected error messages

4. Verify Test Failure

Use Task tool with subagent_type="tdd-workflows::code-reviewer"

Prompt: "Verify that all tests for: $ARGUMENTS are failing correctly. Ensure failures are for the right reasons (missing implementation, not test errors). Confirm no false positives."

Output: Test failure verification report

GATE: Do not proceed until all tests fail appropriately

Phase 3: GREEN - Make Tests Pass

5. Minimal Implementation

Use Task tool with subagent_type="backend-development::backend-architect"

Prompt: "Implement MINIMAL code to make tests pass for: $ARGUMENTS. Focus only on making tests green. Do not add extra features or optimizations. Keep it simple."

Output: Minimal working implementation

Constraint: No code beyond what's needed to pass tests

6. Verify Test Success

Use Task tool with subagent_type="unit-testing::test-automator"

Prompt: "Run all tests for: $ARGUMENTS and verify they pass. Check test coverage metrics. Ensure no tests were accidentally broken."

Output: Test execution report, coverage metrics

GATE: All tests must pass before proceeding

Phase 4: REFACTOR - Improve Code Quality

7. Code Refactoring

Use Task tool with subagent_type="tdd-workflows::code-reviewer"

Prompt: "Refactor implementation for: $ARGUMENTS while keeping tests green. Apply SOLID principles, remove duplication, improve naming, and optimize performance. Run tests after each refactoring."

Output: Refactored code, refactoring report

Constraint: Tests must remain green throughout

8. Test Refactoring

Use Task tool with subagent_type="unit-testing::test-automator"

Prompt: "Refactor tests for: $ARGUMENTS. Remove test duplication, improve test names, extract common fixtures, and enhance test readability. Ensure tests still provide same coverage."

Output: Refactored tests, improved test structure

Validation: Coverage metrics unchanged or improved

Phase 5: Integration and System Tests

9. Write Integration Tests (Failing First)

Use Task tool with subagent_type="unit-testing::test-automator"

Prompt: "Write FAILING integration tests for: $ARGUMENTS. Test component interactions, API contracts, and data flow. Tests must fail initially."

Output: Failing integration tests

Validation: Tests fail due to missing integration logic

10. Implement Integration

Use Task tool with subagent_type="backend-development::backend-architect"

Prompt: "Implement integration code for: $ARGUMENTS to make integration tests pass. Focus on component interaction and data flow."

Output: Integration implementation

Validation: All integration tests pass

Phase 6: Continuous Improvement Cycle

11. Performance and Edge Case Tests

Use Task tool with subagent_type="unit-testing::test-automator"

Prompt: "Add performance tests and additional edge case tests for: $ARGUMENTS. Include stress tests, boundary tests, and error recovery tests."

Output: Extended test suite

Metric: Increased test coverage and scenario coverage

12. Final Code Review

Use Task tool with subagent_type="comprehensive-review::architect-review"

Prompt: "Perform comprehensive review of: $ARGUMENTS. Verify TDD process was followed, check code quality, test quality, and coverage. Suggest improvements."

Output: Review report, improvement suggestions

Action: Implement critical suggestions while maintaining green tests

Incremental Development Mode

For test-by-test development:

Write ONE failing test

Make ONLY that test pass

Refactor if needed

Repeat for next test

Use this approach by adding --incremental flag to focus on one test at a time.

Test Suite Mode

For comprehensive test suite development:

Write ALL tests for a feature/module (failing)

Implement code to pass ALL tests

Refactor entire module

Add integration tests

Use this approach by adding --suite flag for batch test development.

Validation Checkpoints

RED Phase Validation

 All tests written before implementation

 All tests fail with meaningful error messages

 Test failures are due to missing implementation

 No test passes accidentally

GREEN Phase Validation

 All tests pass

 No extra code beyond test requirements

 Coverage meets minimum thresholds

 No test was modified to make it pass

REFACTOR Phase Validation

 All tests still pass after refactoring

 Code complexity reduced

 Duplication eliminated

 Performance improved or maintained

 Test readability improved

Coverage Reports

Generate coverage reports after each phase:

Line coverage

Branch coverage

Function coverage

Statement coverage

Failure Recovery

If TDD discipline is broken:

STOP immediately

Identify which phase was violated

Rollback to last valid state

Resume from correct phase

Document lesson learned

TDD Metrics Tracking

Track and report:

Time in each phase (Red/Green/Refactor)

Number of test-implementation cycles

Coverage progression

Refactoring frequency

Defect escape rate

Anti-Patterns to Avoid

Writing implementation before tests

Writing tests that already pass

Skipping the refactor phase

Writing multiple features without tests

Modifying tests to make them pass

Ignoring failing tests

Writing tests after implementation

Success Criteria

100% of code written test-first

All tests pass continuously

Coverage exceeds thresholds

Code complexity within limits

Zero defects in covered code

Clear test documentation

Fast test execution (< 5 seconds for unit tests)

Notes

Enforce strict RED-GREEN-REFACTOR discipline

Each phase must be completed before moving to next

Tests are the specification

If a test is hard to write, the design needs improvement

Refactoring is NOT optional

Keep test execution fast

Tests should be independent and isolated

TDD implementation for: $ARGUMENTS

Limitations

Use this skill only when the task clearly matches the scope described above.

Do not treat the output as a substitute for environment-specific validation, testing, or expert review.

Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.