Tdd Workflow

TDD Workflow is an AI skill that provides a systematic test-driven development process applicable across programming languages and frameworks. It covers red-green-refactor cycles, test design strategies, incremental development, test prioritization, and refactoring patterns that enable developers to build software with comprehensive test coverage from the start.

What Is This?

Overview

TDD Workflow provides structured approaches to developing software with tests written before implementation. It handles writing minimal failing tests that specify the next piece of desired behavior, implementing just enough code to make the failing test pass, refactoring both test and production code while keeping all tests green, choosing what to test next based on complexity and risk ordering, designing test cases that verify behavior rather than implementation, and maintaining a fast feedback loop through focused test execution.

Who Should Use This

This skill serves developers adopting TDD practices for daily development, teams transitioning to test-first workflows, tech leads establishing quality practices, and engineers learning to write better tests through structured methodology.

Why Use It?

Problems It Solves

Writing tests after implementation leads to tests that verify what was built rather than what was intended. Code without tests accumulates until adding coverage retroactively becomes prohibitively expensive. Large implementation chunks create merge conflicts and review burden. Refactoring without tests risks introducing regressions.

Core Highlights

Red-green-refactor provides a repeatable rhythm that maintains focus and progress. Incremental development produces small, reviewable changes with immediate test evidence. Behavior-focused tests remain stable when internal implementation changes. Continuous refactoring prevents technical debt accumulation during development.

How to Use It?

Basic Usage

import pytest

def test_empty_cart_total():
    cart = ShoppingCart()
    assert cart.total() == 0

class ShoppingCart:
    def __init__(self):
        self.items = []

    def total(self):
        return sum(item["price"] * item["qty"] for item in self.items)

    def add(self, name, price, qty=1):
        self.items.append({"name": name, "price": price, "qty": qty})

def test_single_item_total():
    cart = ShoppingCart()
    cart.add("Widget", 10.0)
    assert cart.total() == 10.0

def test_multiple_items_total():
    cart = ShoppingCart()
    cart.add("Widget", 10.0, qty=2)
    cart.add("Gadget", 5.0)
    assert cart.total() == 25.0

def test_discount_applied():
    cart = ShoppingCart()
    cart.add("Widget", 100.0)
    cart.apply_discount(10)
    assert cart.total() == 90.0

Real-World Examples

class ShoppingCart:
    def __init__(self):
        self.items = []
        self.discount_pct = 0

    def add(self, name, price, qty=1):
        self.items.append(
            {"name": name, "price": price, "qty": qty}
        )

    def remove(self, name):
        self.items = [
            i for i in self.items if i["name"] != name
        ]

    def apply_discount(self, percentage):
        if percentage < 0 or percentage > 100:
            raise ValueError("Invalid discount")
        self.discount_pct = percentage

    def subtotal(self):
        return sum(
            i["price"] * i["qty"] for i in self.items
        )

    def total(self):
        sub = self.subtotal()
        return sub * (1 - self.discount_pct / 100)

    def item_count(self):
        return sum(i["qty"] for i in self.items)

class TestShoppingCart:
    def test_empty_cart(self):
        cart = ShoppingCart()
        assert cart.total() == 0
        assert cart.item_count() == 0

    def test_add_and_remove(self):
        cart = ShoppingCart()
        cart.add("A", 10.0)
        cart.add("B", 20.0)
        assert cart.item_count() == 2
        cart.remove("A")
        assert cart.item_count() == 1
        assert cart.total() == 20.0

    def test_invalid_discount(self):
        cart = ShoppingCart()
        with pytest.raises(ValueError):
            cart.apply_discount(150)

    def test_quantity_handling(self):
        cart = ShoppingCart()
        cart.add("Widget", 15.0, qty=3)
        assert cart.subtotal() == 45.0
        assert cart.item_count() == 3

Advanced Tips

Start with the simplest possible test case and incrementally add complexity through new tests. Run only the relevant test during the red-green cycle for fast feedback, then run the full suite before committing. Use the refactor step to extract common patterns once tests confirm behavior.

When to Use It?

Use Cases

Use TDD Workflow when developing new features where requirements are well understood, when fixing bugs by first writing a test that reproduces the failure, when refactoring existing code that needs test coverage, or when building libraries with well-defined public APIs.

Related Topics

Behavior-driven development, pytest fixtures and parametrize, refactoring patterns, continuous integration test automation, and test double strategies complement TDD workflow.

Important Notes

Requirements

Test framework configured for the target language. Fast test execution environment for rapid feedback cycles. Understanding of test design principles and assertion patterns.

Usage Recommendations

Do: write the smallest possible failing test at each step to maintain focus. Run tests frequently during development for immediate feedback. Refactor both test and production code during the refactor phase.

Don't: skip the refactor step, which allows code quality to degrade over time. Write multiple tests at once before implementing, which breaks the incremental cycle. Test implementation details that make tests brittle when internals change.

Limitations

TDD adds upfront time that pays off later but may feel slow initially. Some code like UI layouts and third-party integrations are difficult to test-drive effectively. Poorly designed tests can create maintenance burden rather than reducing it.