Test-Driven Development

Part of Agent Skills™ by googleadsagent.ai™

Description

Test-Driven Development enforces the RED-GREEN-REFACTOR discipline on every code change an agent produces. The agent writes a failing test first, confirms the failure, writes the minimal code to pass, confirms the pass, refactors for clarity, and commits. No production code exists without a corresponding test that demanded its creation.

This skill eliminates the most common agent anti-pattern: generating large blocks of untested code that "look right" but silently break under edge cases. By forcing the agent through the TDD cycle, each line of production code is justified by a specific test assertion. The result is a codebase where test coverage is not an afterthought but a structural guarantee.

The cycle integrates directly with version control. Each RED-GREEN-REFACTOR iteration produces an atomic commit, creating a reviewable history of design decisions. The refactor phase is mandatory—the agent must evaluate naming, duplication, and structural clarity before moving to the next feature increment.

Use When

• Writing any new function, method, or module
• Fixing a bug (write the test that exposes the bug first)
• Refactoring existing code (ensure tests pass before and after)
• The user requests "TDD", "test-first", or "red-green-refactor"
• Building APIs, data transformations, or business logic
• You need confidence that a change does not introduce regressions

How It Works

graph LR
    R[RED: Write Failing Test] --> G[GREEN: Minimal Code to Pass]
    G --> RF[REFACTOR: Clean Up]
    RF --> C[COMMIT: Atomic Commit]
    C --> R
    style R fill:#e74c3c,color:#fff
    style G fill:#2ecc71,color:#fff
    style RF fill:#3498db,color:#fff
    style C fill:#95a5a6,color:#fff

RED: Write a test that describes the next small behavior increment. Run it. Confirm it fails for the expected reason—not a syntax error or import failure, but a genuine assertion failure. GREEN: Write the simplest production code that makes the test pass. Resist the urge to generalize. REFACTOR: Improve names, extract duplication, simplify control flow. All tests must still pass. COMMIT: Stage and commit with a message referencing the behavior added.

Implementation

# RED: Write the failing test first
def test_calculate_discount_applies_ten_percent_for_orders_over_100():
    order = Order(items=[Item(price=150.00)])
    result = calculate_discount(order)
    assert result == 135.00  # 10% off

# Run: pytest => FAIL (calculate_discount not defined)

# GREEN: Minimal implementation
def calculate_discount(order):
    total = sum(item.price for item in order.items)
    if total > 100:
        return total * 0.9
    return total

# Run: pytest => PASS

# REFACTOR: Extract magic numbers
DISCOUNT_THRESHOLD = 100
DISCOUNT_RATE = 0.10

def calculate_discount(order):
    total = sum(item.price for item in order.items)
    if total > DISCOUNT_THRESHOLD:
        return total * (1 - DISCOUNT_RATE)
    return total

# Run: pytest => PASS
# git commit -m "feat: apply 10% discount for orders over $100"

Anti-Patterns to Avoid

Best Practices

• Each RED-GREEN-REFACTOR cycle should take under 5 minutes
• If GREEN requires more than 10 lines, the test is too ambitious—split it
• Name tests as behavior specifications: test_<action>_<condition>_<outcome>
• Run the full test suite after every REFACTOR, not just the new test
• Commit after each complete cycle to preserve the design narrative
• Use test doubles (mocks, stubs) only at architectural boundaries

Platform Compatibility

Related Skills

• Systematic Debugging - Root cause analysis that starts by writing a failing test reproducing the bug
• Code Review - Quality gate that verifies test coverage alongside production code changes
• Subagent-Driven Development - Isolated subagents that follow TDD cycles independently for each subtask

Keywords

tdd test-driven-development red-green-refactor failing-test-first test-first unit-testing regression-prevention atomic-commits

© 2026 googleadsagent.ai™ | Agent Skills™ | MIT License