TDD Workflow and Test Coverage Requirements for Claude Code: A Complete Guide

Claude Code enforces a strict seven-step Test-Driven Development (TDD) workflow requiring a minimum of 80% test coverage across unit, integration, and end-to-end test suites.

The everything-claude-code repository by affaan-m implements a rigorous, disciplined approach to software quality through its tdd-workflow skill. This system mandates that developers write failing tests before implementation, maintain comprehensive coverage across three testing layers, and follow a linear red-green-refactor cycle documented in the repository's skill files.

The Seven-Step TDD Workflow in Claude Code

Claude Code's TDD workflow is intentionally linear and enforced through the skills/tdd-workflow/SKILL.md file. The process follows the classic red-green-refactor cycle with specific steps documented at precise line ranges.

Write User Journeys

The workflow begins with stakeholder-focused documentation. Developers first write user journeys that describe desired behavior from an end-user perspective. This step is documented in the skill file at lines 52-59, establishing the behavioral foundation before any code is written.

Generate Concrete Test Cases

For each user journey, developers must generate concrete test cases covering happy paths, edge cases, and error handling scenarios. This comprehensive test definition ensures that all behavioral requirements have corresponding verifications before implementation begins.

Run Tests First (Red Phase)

The workflow explicitly requires running tests before writing implementation code. As documented at lines 84-88 in skills/tdd-workflow/SKILL.md, tests must fail initially because the implementation does not exist yet. This confirms that the test suite correctly detects missing functionality.

Implement Minimal Code (Green Phase)

Developers then implement the minimal code required to make the failing tests pass. This step focuses on the simplest possible solution that satisfies the current test suite without over-engineering or adding unverified functionality.

Re-run Tests to Confirm

After implementation, developers re-run the tests to confirm they now succeed. This verification step ensures that the new code correctly satisfies the previously defined behavioral requirements.

Refactor While Green

The final development step involves refactoring production code while keeping the test suite green. This optimization improves code quality, performance, and maintainability without changing external behavior.

Verify Coverage Compliance

The workflow concludes with coverage verification to ensure the required 80% thresholds are met across all test categories. This gate prevents code that lacks sufficient test coverage from entering the codebase.

Test Coverage Requirements and Thresholds

Claude Code enforces strict minimum 80% test coverage across three distinct test categories, as defined in the "Coverage Requirements" section at lines 24-28 of skills/tdd-workflow/SKILL.md.

Unit Test Coverage

Unit tests must achieve 80% coverage of individual functions, components, and utilities. These tests isolate discrete units of code and verify their behavior in controlled conditions, typically using Jest and React Testing Library for UI components.

Integration Test Coverage

Integration tests require 80% coverage of API routes, database interactions, and external service calls. These tests verify that multiple components work correctly together, ensuring that data flows properly through the application's layers.

End-to-End (Playwright) Coverage

End-to-end tests must achieve 80% coverage of critical user flows. Using Playwright, these tests simulate real user interactions across the entire application stack, validating complete user journeys from the browser perspective.

Jest Configuration Thresholds

The repository encodes these requirements in its Jest configuration. As shown at lines 100-108 in skills/tdd-workflow/SKILL.md, the coverage thresholds enforce minimum 80% for branches, functions, lines, and statements:

{
  "coverageThreshold": {
    "global": {
      "branches": 80,
      "functions": 80,
      "lines": 80,
      "statements": 80
    }
  }
}

Code Examples and Test Patterns

The skills/tdd-workflow/SKILL.md file provides concrete implementation patterns for each test category, with examples referencing specific file paths in the repository.

Unit Test Pattern

The unit test example demonstrates testing a React Button component using Jest and React Testing Library. This pattern appears at lines 21-45 in the skill file and corresponds to the implementation in src/components/Button/Button.test.tsx:

import { render, screen, fireEvent } from '@testing-library/react';
import { Button } from './Button';

describe('Button Component', () => {
  it('renders with correct text', () => {
    render(<Button>Click me</Button>);
    expect(screen.getByText('Click me')).toBeInTheDocument();
  });

  it('calls onClick when clicked', () => {
    const handleClick = jest.fn();
    render(<Button onClick={handleClick}>Click</Button>);
    fireEvent.click(screen.getByRole('button'));
    expect(handleClick).toHaveBeenCalledTimes(1);
  });

  it('is disabled when disabled prop is true', () => {
    render(<Button disabled>Click</Button>);
    expect(screen.getByRole('button')).toBeDisabled();
  });
});

Integration Test Pattern

The integration test example validates API routes using Next.js Request/Response objects. Documented at lines 48-63 in the skill file and implemented in src/app/api/markets/route.test.ts:

import { NextRequest } from 'next/server';
import { GET } from './route';

describe('GET /api/markets', () => {
  it('returns markets successfully', async () => {
    const request = new NextRequest('http://localhost/api/markets');
    const response = await GET(request);
    const data = await response.json();

    expect(response.status).toBe(200);
    expect(data.success).toBe(true);
    expect(Array.isArray(data.data)).toBe(true);
  });
});

E2E Test Pattern

The end-to-end test example uses Playwright to simulate complete user flows. Found at lines 78-108 in the skill file and corresponding to e2e/markets.spec.ts:

import { test, expect } from '@playwright/test';

test('user can search and filter markets', async ({ page }) => {
  await page.goto('/');
  await page.click('a[href="/markets"]');
  await expect(page.locator('h1')).toContainText('Markets');

  await page.fill('input[placeholder="Search markets"]', 'election');
  await page.waitForTimeout(600);

  const results = page.locator('[data-testid="market-card"]');
  await expect(results).toHaveCount(5, { timeout: 5000 });
  await expect(results.first()).toContainText('election', { ignoreCase: true });

  await page.click('button:has-text("Active")');
  await expect(results).toHaveCount(3);
});

Running Coverage Checks

To verify compliance with the 80% threshold, the repository provides a dedicated coverage script. As documented at lines 94-98 in skills/tdd-workflow/SKILL.md:

npm run test:coverage

# The report should show ≥ 80 % for branches, functions, lines and statements

Key Files and Implementation Details

The TDD workflow and coverage requirements are implemented across several critical files in the affaan-m/everything-claude-code repository:

File	Role	Location
skills/tdd-workflow/SKILL.md	Defines the full TDD workflow, coverage goals, test patterns and mock configurations	skills/tdd-workflow/SKILL.md
src/components/Button/Button.test.tsx	Example unit test for a React component (illustrates the “Unit Test Pattern”)	src/components/Button/Button.test.tsx
src/app/api/markets/route.test.ts	Integration test for the markets API endpoint (illustrates the “API Integration Test Pattern”)	src/app/api/markets/route.test.ts
e2e/markets.spec.ts	Playwright end-to-end test exercising a user journey (illustrates the “E2E Test Pattern”)	e2e/markets.spec.ts
package.json	Provides test and coverage scripts referenced throughout the workflow	package.json

These files collectively demonstrate how Claude Code implements a rigorous TDD process while guaranteeing at least 80% test coverage across unit, integration, and end-to-end suites.

Summary

• Claude Code follows a strict seven-step TDD workflow outlined in skills/tdd-workflow/SKILL.md, requiring developers to write failing tests before implementation and refactor while maintaining green test suites.
• Minimum 80% coverage is mandatory across all three test categories: unit tests (individual functions/components), integration tests (API routes and database interactions), and end-to-end tests (Playwright user flows).
• Concrete test patterns are provided for each category, with working examples in src/components/Button/Button.test.tsx, src/app/api/markets/route.test.ts, and e2e/markets.spec.ts.
• Coverage verification is enforced through Jest configuration thresholds (branches, functions, lines, statements ≥ 80%) and the npm run test:coverage command.

Frequently Asked Questions

What is the minimum test coverage requirement for Claude Code?

Claude Code requires a minimum of 80% test coverage across all codebases. This threshold applies uniformly to four metric categories: branches, functions, lines, and statements. The requirement is enforced through Jest configuration in skills/tdd-workflow/SKILL.md (lines 100-108) and applies to unit tests, integration tests, and end-to-end Playwright tests alike.

How does Claude Code implement the red-green-refactor cycle?

The repository implements the red-green-refactor cycle through a seven-step linear workflow defined in skills/tdd-workflow/SKILL.md. First, developers write user journeys and generate test cases (red phase preparation). Then they run tests to confirm they fail (red phase), implement minimal code to make them pass (green phase), and refactor while keeping tests green. The "Run Tests (They Should Fail)" step is explicitly documented at lines 84-88 of the skill file.

What types of tests are required in the Claude Code workflow?

Claude Code mandates three distinct test categories with equal 80% coverage requirements. Unit tests cover individual functions and React components using Jest and React Testing Library. Integration tests validate API routes, database interactions, and external service calls. End-to-end tests use Playwright to simulate complete user journeys through the browser. Each category has specific implementation patterns demonstrated in src/components/Button/Button.test.tsx, src/app/api/markets/route.test.ts, and e2e/markets.spec.ts.

Where is the TDD workflow documented in the repository?

The primary documentation resides in skills/tdd-workflow/SKILL.md at the repository root. This file defines the complete seven-step workflow, coverage thresholds, Jest configuration requirements, and concrete test patterns. Additional implementation examples are located in src/components/Button/Button.test.tsx (unit tests), src/app/api/markets/route.test.ts (integration tests), and e2e/markets.spec.ts (end-to-end tests), while the test scripts are defined in the project's package.json.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}