playbooks

home / skills / yeachan-heo / oh-my-claudecode / tdd

tdd skill

/skills/tdd

This skill enforces test-driven development by guiding you through red-green-refactor cycles and ensuring tests precede production code.

npx playbooks add skill yeachan-heo/oh-my-claudecode --skill tdd

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.6 KB
---
name: tdd
description: Test-Driven Development enforcement skill - write tests first, always
---

# TDD Mode

[TDD MODE ACTIVATED]

## The Iron Law

**NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST**

Write code before test? DELETE IT. Start over. No exceptions.

## Red-Green-Refactor Cycle

### 1. RED: Write Failing Test
- Write test for the NEXT piece of functionality
- Run test - MUST FAIL
- If it passes, your test is wrong

### 2. GREEN: Minimal Implementation
- Write ONLY enough code to pass the test
- No extras. No "while I'm here."
- Run test - MUST PASS

### 3. REFACTOR: Clean Up
- Improve code quality
- Run tests after EVERY change
- Must stay green

### 4. REPEAT
- Next failing test
- Continue cycle

## Enforcement Rules

| If You See | Action |
|------------|--------|
| Code written before test | STOP. Delete code. Write test first. |
| Test passes on first run | Test is wrong. Fix it to fail first. |
| Multiple features in one cycle | STOP. One test, one feature. |
| Skipping refactor | Go back. Clean up before next feature. |

## Commands

Before each implementation:
```bash
# Run the project's test command - should have ONE new failure
```

After implementation:
```bash
# Run the project's test command - new test should pass, all others still pass
```

## Output Format

When guiding TDD:

```
## TDD Cycle: [Feature Name]

### RED Phase
Test: [test code]
Expected failure: [what error you expect]
Actual: [run result showing failure]

### GREEN Phase
Implementation: [minimal code]
Result: [run result showing pass]

### REFACTOR Phase
Changes: [what was cleaned up]
Result: [tests still pass]
```

## External Model Consultation (Preferred)

The tdd-guide agent SHOULD consult Codex for test strategy validation.

### Protocol
1. **Form your OWN test strategy FIRST** - Design tests independently
2. **Consult for validation** - Cross-check test coverage strategy
3. **Critically evaluate** - Never blindly adopt external suggestions
4. **Graceful fallback** - Never block if tools unavailable

### When to Consult
- Complex domain logic requiring comprehensive test coverage
- Edge case identification for critical paths
- Test architecture for large features
- Unfamiliar testing patterns

### When to Skip
- Simple unit tests
- Well-understood testing patterns
- Time-critical TDD cycles
- Small, isolated functionality

### Tool Usage
Before first MCP tool use, call `ToolSearch("mcp")` to discover deferred MCP tools.
Use `mcp__x__ask_codex` with `agent_role: "tdd-guide"`.
If ToolSearch finds no MCP tools, fall back to the `test-engineer` Claude agent.

**Remember:** The discipline IS the value. Shortcuts destroy the benefit.

Overview

This skill enforces strict Test-Driven Development (TDD) discipline for TypeScript agentic coding workflows. It ensures every feature starts with a failing test, follows the red-green-refactor cycle, and prevents production code from being introduced before tests. The skill integrates test strategy checks, minimal implementation guidance, and optional external consultation for complex cases.

How this skill works

The skill inspects code changes and test runs to verify the TDD cycle: a new failing test, a minimal implementation to make it pass, and a refactor that keeps the suite green. It rejects or flags commits that contain production code without a preceding failing test, multi-feature changes in one cycle, or skipped refactor steps. For complex features it recommends consulting an external model (Codex) for test strategy validation while preserving the agent's independent design.

When to use it

  • Developing new features where correctness and regressions matter.
  • Working in multi-agent TypeScript projects that require coordinated, test-safe changes.
  • Enforcing team-wide standards for coding discipline and maintainability.
  • Onboarding contributors to ensure consistent TDD practices.
  • Validating test coverage and edge cases for critical domain logic.

Best practices

  • Always write the next failing test first; if the test passes immediately, rewrite it to fail.
  • Implement only the minimal code required to pass the test—no extras or unrelated improvements.
  • Run the full test suite after every change and ensure all tests remain green before committing.
  • Keep cycles small: one test and one feature per red-green-refactor iteration.
  • Use external consultation (Codex) only for complex test strategy validation, not as a primary design authority.

Example use cases

  • Adding a new feature to an agent: create a failing unit test for the new behavior, implement minimal changes in TypeScript, refactor and re-run tests.
  • Hardening a shared library: introduce regression tests for edge cases, then implement fixes using TDD cycles to avoid regressions across agents.
  • Code review enforcement: detect and block PRs that contain production code without accompanying failing tests.
  • Cross-agent coordination: write integration tests that fail first to drive compatible implementations across multiple agents.
  • Mentoring new contributors: demonstrate red-green-refactor cycles and require adherence on their first contributions.

FAQ

What if a test suite takes too long to run for every small change?

Prioritize fast unit tests in each cycle and run the full suite at key checkpoints (pre-merge CI). Keep cycles small so individual test runs remain quick.

When should I consult Codex or an external model?

Consult external models for complex domain logic, edge case identification, or designing broad test strategies. Always create your own test plan first and critically evaluate any external suggestions.