Why TDD is Essential with AI

Tests are your safety net against AI mistakes

TDD in the AIDD Workflow

Where Test-Driven Development fits

The TDD Cycle: Red-Green-Refactor

TDD with AI: The Workflow

Example: User Registration (RED)

Step 1: Write a failing test for the first requirement

# test_user_registration.py
import pytest
from app.auth import register_user

def test_register_user_with_valid_data():
    """User can register with valid email and password."""
    result = register_user(
        email="test@example.com",
        password="SecurePass123"
    )

    assert result.success is True
    assert result.user.email == "test@example.com"
    assert result.user.id is not None

def test_register_user_with_invalid_email():
    """Registration fails with invalid email format."""
    result = register_user(
        email="not-an-email",
        password="SecurePass123"
    )

    assert result.success is False
    assert "email" in result.errors

Example: User Registration (GREEN)

Step 2: Ask AI to implement the minimum code to pass

# app/auth.py (AI-generated)
import re
from dataclasses import dataclass

@dataclass
class User:
    id: str
    email: str

@dataclass
class RegistrationResult:
    success: bool
    user: User = None
    errors: dict = None

def register_user(email: str, password: str) -> RegistrationResult:
    errors = {}

    # Validate email (simple RFC 5322 pattern)
    if not re.match(r'^[\w\.-]+@[\w\.-]+\.\w+$', email):
        errors['email'] = 'Invalid email format'

    # Validate password
    if len(password) < 8 or not re.search(r'[A-Z]', password) or not re.search(r'\d', password):
        errors['password'] = 'Password must be 8+ chars with 1 uppercase and 1 number'

    if errors:
        return RegistrationResult(success=False, errors=errors)

    user = User(id=str(uuid.uuid4()), email=email)
    return RegistrationResult(success=True, user=user)

Example: User Registration (REFACTOR)

Step 3: Clean up while keeping tests green

The Golden Rule: One Test at a Time

Write all tests first:
- test_valid_registration
- test_invalid_email
- test_weak_password
- test_duplicate_email
- test_email_verification

Then implement everything

Cycle 1: test_valid_registration
  → implement → pass → refactor

Cycle 2: test_invalid_email
  → implement → pass → refactor

Cycle 3: test_weak_password
  → implement → pass → refactor

...

Types of Tests in TDD

Using AI to Generate Tests

AI can help write tests, but YOU validate them

Common TDD Mistakes to Avoid

Effective Test Prompts for AI

Generate pytest tests for [function].

Test cases needed:
1. [Normal case]
2. [Edge case 1]
3. [Error case]

Use fixtures for setup.
Include docstrings explaining
each test's purpose.

Here is my failing test:
[paste test code]

Implement the function to make
this test pass.

- Use only standard library
- Follow existing code style
- Add type hints
- Minimal implementation

Code Coverage Fundamentals

Measure what your tests actually test

Measuring Coverage

# Python (pytest-cov)
pytest --cov=app --cov-report=html --cov-branch

# JavaScript (Jest)
jest --coverage --collectCoverageFrom='src/**/*.js'

# Java (JaCoCo)
mvn test jacoco:report

Name              Stmts  Branch  Cover
---------------------------------------
app/auth.py          45      12    93%
app/models.py        22       4   100%
app/utils.py         18       8    61%
---------------------------------------
TOTAL               85      24    88%

Coverage Targets by Code Type

Enforcing Coverage in CI/CD

# pytest.ini - fail under threshold
[pytest]
addopts = --cov=app --cov-fail-under=80

# GitHub Actions workflow
- name: Run tests with coverage
  run: pytest --cov=app --cov-report=xml

- name: Upload to Codecov
  uses: codecov/codecov-action@v3

- name: Coverage gate
  run: |
    coverage report --fail-under=80

TDD Best Practices with AI

Key Takeaways