Skip to main content
skill CX Codex

tdd-guide · alirezarezvani/claude-code-skill-factory — Claude Code skill: testing and setup

tdd-guide is a Claude Code skill that generates tests from requirements or code, reviews coverage, and guides Red-Green-Refactor to find untested scenarios.

MIT ★ 907 updated 2025-11-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add alirezarezvani/claude-code-skill-factory --skill tdd-guide -a claude-code
Open on GitHub

What tdd-guide does

tdd-guide can turn user stories, API specs, or code into test cases, scaffolds, fixtures, and mocks. It also reviews test quality and points out edge cases. Framework adapters cover Jest, Pytest, JUnit, Vitest, Mocha, and RSpec.

The skill reads LCOV, JSON, and XML coverage reports to locate uncovered branches and error handlers. Its Python modules handle test generation, coverage analysis, metrics, and format detection. You can provide code directly or give a file path; the listed source languages are TypeScript, JavaScript, Python, and Java. Projects written in other languages fall outside that stated support.

What it helps with

  • Turn a user story or API specification into executable tests
  • Build fixtures and mocks for test scenarios
  • Locate uncovered branches and error handlers
  • Rank test-quality and coverage gaps by priority

Example prompts for the agent

  • Write tests for this authentication module, including failure paths and edge cases.
  • Analyze my TypeScript coverage report at coverage/lcov.info and rank the gaps.
  • Guide me through Red-Green-Refactor for a password validation function.

How to install tdd-guide

1Skills CLI (Vercel)

npx skills add alirezarezvani/claude-code-skill-factory --skill tdd-guide -a claude-code

2Manually: put the files in place

~/.claude/skills/tdd-guide/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/tdd-guide/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about tdd-guide

How do I install tdd-guide in Claude Code?

Run npx skills add alirezarezvani/claude-code-skill-factory --skill tdd-guide -a claude-code, then use ~/.claude/skills/tdd-guide/SKILL.md.

What does tdd-guide do?

It creates tests and test data, examines coverage reports, and checks test quality. It can also guide you through Red-Green-Refactor.

Which languages and testing frameworks does tdd-guide support?

The listed source languages are TypeScript, JavaScript, Python, and Java. Framework adapters include Jest, Pytest, JUnit, Vitest, Mocha, and RSpec.

Source text

SKILL.md · MIT
---
name: tdd-guide
description: Comprehensive Test Driven Development guide for engineering subagents with multi-framework support, coverage analysis, and intelligent test generation
---

# TDD Guide - Test Driven Development for Engineering Teams

A comprehensive Test Driven Development skill that provides intelligent test generation, coverage analysis, framework integration, and TDD workflow guidance across multiple languages and testing frameworks.

## Capabilities

### Test Generation
- **Generate Test Cases from Requirements**: Convert user stories, API specs, and business requirements into executable test cases
- **Create Test Stubs**: Generate test function scaffolding with proper naming, imports, and setup/teardown
- **Generate Test Fixtures**: Create realistic test data, mocks, and fixtures for various scenarios

### TDD Workflow Support
- **Guide Red-Green-Refactor**: Step-by-step guidance through TDD cycles with validation
- **Suggest Missing Scenarios**: Identify untested edge cases, error conditions, and boundary scenarios
- **Review Test Quality**: Analyze test isolation, assertions quality, naming conventions, and maintainability

### Coverage & Metrics Analysis
- **Calculate Coverage**: Parse LCOV, JSON, and XML coverage reports for line/branch/function coverage
- **Identify Untested Paths**: Find code paths, branches, and error handlers without test coverage
- **Recommend Improvements**: Prioritized recommendations (P0/P1/P2) for coverage gaps and test quality

### Framework Integration
- **Multi-Framework Support**: Jest, Pytest, JUnit, Vitest, Mocha, RSpec adapters
- **Generate Boilerplate**: Create test files with proper imports, describe blocks, and best practices
- **Configure Test Runners**: Set up test configuration, coverage tools, and CI integration

### Comprehensive Metrics
- **Test Coverage**: Line, branch, function coverage with gap analysis
- **Code Complexity**: Cyclomatic complexity, cognitive complexity, testability scoring
- **Test Quality**: Assertions per test, isolation score, naming quality, test smell detection
- **Test Data**: Boundary value analysis, edge case identification, mock data generation
- **Test Execution**: Timing analysis, slow test detection, flakiness detection
- **Missing Tests**: Uncovered edge cases, error handling gaps, missing integration scenarios

## Input Requirements

The skill supports **automatic format detection** for flexible input:

### Source Code
- **Languages**: TypeScript, JavaScript, Python, Java
- **Format**: Direct file paths or copy-pasted code blocks
- **Detection**: Automatic language/framework detection from syntax and imports

### Test Artifacts
- **Coverage Reports**: LCOV (.lcov), JSON (coverage-final.json), XML (cobertura.xml)
- **Test Results**: JUnit XML, Jest JSON, Pytest JSON, TAP format
- **Format**: File paths or raw coverage data

### Requirements (Optional)
- **User Stories**: Text descriptions of functionality
- **API Specifications**: OpenAPI/Swagger, REST endpoints, GraphQL schemas
- **Business Requirements**: Acceptance criteria, business rules

### Input Methods
- **Option A**: Provide file paths (skill will read files)
- **Option B**: Copy-paste code/data directly
- **Option C**: Mix of both (automatically detected)

## Output Formats

The skill provides **context-aware output** optimized for your environment:

### Code Files
- **Test Files**: Generated tests (Jest/Pytest/JUnit/Vitest) with proper structure
- **Fixtures**: Test data files, mock objects, factory functions
- **Mocks**: Mock implementations, stub functions, test doubles

### Reports
- **Markdown**: Rich coverage reports, recommendations, quality analysis (Claude Desktop)
- **JSON**: Machine-readable metrics, structured data for CI/CD integration
- **Terminal-Friendly**: Simplified output for Claude Code CLI

### Smart Defaults
- **Desktop/Apps**: Rich markdown with tables, code blocks, visual hierarchy
- **CLI**: Concise, terminal-friendly format with clear sections
- **CI/CD**: JSON output for automated processing

### Progressive Disclosure
- **Summary First**: High-level overview (<200 tokens)
- **Details on Demand**: Full analysis available (500-1000 tokens)
- **Prioritized**: P0 (critical) → P1 (important) → P2 (nice-to-have)

## How to Use

### Basic Usage
```
@tdd-guide

I need tests for my authentication module. Here's the code:
[paste code or provide file path]

Generate comprehensive test cases covering happy path, error cases, and edge cases.
```

### Coverage Analysis
```
@tdd-guide

Analyze test coverage for my TypeScript project. Coverage report: coverage/lcov.info

Identify gaps and provide prioritized recommendations.
```

### TDD Workflow
```
@tdd-guide

Guide me through TDD for implementing a password validation function.

Requirements:
- Min 8 characters
- At least 1 uppercase, 1 lowercase, 1 number, 1 special char
- No common passwords
```

### Multi-Framework Support
```
@tdd-guide

Convert these Jest tests to Pytest format:
[paste Jest tests]
```

## Scripts

### Core Modules

- **test_generator.py**: Intelligent test case generation from requirements and code
- **coverage_analyzer.py**: Parse and analyze coverage reports (LCOV, JSON, XML)
- **metrics_calculator.py**: Calculate comprehensive test and code quality metrics
- **framework_adapter.py**: Multi-framework adapter (Jest, Pytest, JUnit, Vitest)
- **tdd_workflow.py**: Red-green-refactor workflow guidance and validation
- **fixture_generator.py**: Generate realistic test data and fixtures
- **format_detector.py**: Automatic language and framework detection

### Utilities

- **complexity_analyzer.py**: Cyclomatic and cognitive complexity analysis
- **test_quality_scorer.py**: Test quality scoring (isolation, assertions, naming)
- **missing_test_detector.py**: Identify untested paths and missing scenarios
- **output_formatter.py**: Context-aware output formatting (Desktop vs CLI)

## Best Practices

### Test Generation
1. **Start with Requirements**: Write tests from user stories before seeing implementation
2. **Test Behavior, Not Implementation**: Focus on what code does, not how it does it
3. **One Assertion Focus**: Each test should verify one specific behavior
4. **Descriptive Names**: Test names should read like specifications

### TDD Workflow
1. **Red**: Write failing test first
2. **Green**: Write minimal code to make it pass
3. **Refactor**: Improve code while keeping tests green
4. **Repeat**: Small iterations, frequent commits

### Coverage Goals
1. **Aim for 80%+**: Line coverage baseline for most projects
2. **100% Critical Paths**: Authentication, payments, data validation must be fully covered
3. **Branch Coverage Matters**: Line coverage alone is insufficient
4. **Don't Game Metrics**: Focus on meaningful tests, not coverage numbers

### Test Quality
1. **Independent Tests**: Each test should run in isolation
2. **Fast Execution**: Keep unit tests under 100ms each
3. **Deterministic**: Tests should always produce same results
4. **Clear Failures**: Assertion messages should explain what went wrong

### Framework Selection
1. **Jest**: JavaScript/TypeScript projects (React, Node.js)
2. **Pytest**: Python projects (Django, Flask, FastAPI)
3. **JUnit**: Java projects (Spring, Android)
4. **Vitest**: Modern Vite-based projects

## Multi-Language Support

### TypeScript/JavaScript
- Frameworks: Jest, Vitest, Mocha, Jasmine
- Runners: Node.js, Karma, Playwright
- Coverage: Istanbul/nyc, c8

### Python
- Frameworks: Pytest, unittest, nose2
- Runners: pytest, tox, nox
- Coverage: coverage.py, pytest-cov

### Java
- Frameworks: JUnit 5, TestNG, Mockito
- Runners: Maven Surefire, Gradle Test
- Coverage: JaCoCo, Cobertura

## Limitations

### Scope
- **Unit Tests Focus**: Primarily optimized for unit tests (integration tests require different patterns)
- **Static Analysis Only**: Cannot execute tests or measure actual code behavior
- **Language Support**: Best support for TypeScript, JavaScript, Python, Java (other languages limited)

### Coverage Analysis
- **Report Dependency**: Requires existing coverage reports (cannot generate coverage from scratch)
- **Format Support**: LCOV, JSON, XML only (other formats need conversion)
- **Interpretation Context**: Coverage numbers need human judgment for meaningfulness

### Test Generation
- **Baseline Quality**: Generated tests provide scaffolding, require human review and refinement
- **Complex Logic**: Advanced business logic and integration scenarios need manual test design
- **Mocking Strategy**: Mock/stub strategies should align with project patterns

### Framework Integration
- **Configuration Required**: Test runners need proper setup (this skill doesn't modify package.json or pom.xml)
- **Version Compatibility**: Generated code targets recent stable versions (Jest 29+, Pytest 7+, JUnit 5+)

### When NOT to Use This Skill
- **E2E Testing**: Use dedicated E2E tools (Playwright, Cypress, Selenium)
- **Performance Testing**: Use JMeter, k6, or Locust
- **Security Testing**: Use OWASP ZAP, Burp Suite, or security-focused tools
- **Manual Testing**: Some scenarios require human exploratory testing

## Example Workflows

### Workflow 1: Generate Tests from Requirements
```
Input: User story + API specification
Process: Parse requirements → Generate test cases → Create test stubs
Output: Complete test files ready for implementation
```

### Workflow 2: Improve Coverage
```
Input: Coverage report + source code
Process: Identify gaps → Suggest tests → Generate test code
Output: Prioritized test cases for uncovered code
```

### Workflow 3: TDD New Feature
```
Input: Feature requirements
Process: Guide red-green-refactor → Validate each step → Suggest refactorings
Output: Well-tested feature with clean code
```

### Workflow 4: Framework Migration
```
Input: Tests in Framework A
Process: Parse tests → Translate patterns → Generate equivalent tests
Output: Tests in Framework B with same coverage
```

## Integration Points

### CI/CD Integration
- Parse coverage reports from CI artifacts
- Generate coverage badges and reports
- Fail builds on coverage thresholds
- Track coverage trends over time

### IDE Integration
- Generate tests for selected code
- Run coverage analysis on save
- Highlight untested code paths
- Quick-fix suggestions for test gaps

### Code Review
- Validate test coverage in PRs
- Check test quality standards
- Identify missing test scenarios
- Suggest improvements before merge

## Version Support

- **Node.js**: 16+ (Jest 29+, Vitest 0.34+)
- **Python**: 3.8+ (Pytest 7+)
- **Java**: 11+ (JUnit 5.9+)
- **TypeScript**: 4.5+

## Related Skills

This skill works well with:
- **code-review**: Validate test quality during reviews
- **refactoring-assistant**: Maintain tests during refactoring
- **ci-cd-helper**: Integrate coverage in pipelines
- **documentation-generator**: Generate test documentation

© alirezarezvani · MIT · alirezarezvani/claude-code-skill-factory

Similar skills

All skills for Testing and QA →

tdd-guide by other authors comes first.

tdd-guide Alireza Rezvani tdd-guide guides test-driven development, builds unit tests, and detects test coverage gaps. It supports Jest, Pytest, JUnit, and Vitest projects. CX Codex +1 1,017installs tdd-guide borghei The tdd-guide Claude Code skill guides red-green-refactor cycles and works with test suites. It can draft tests from requirements and inspect coverage reports for gaps. CX Codex +1 143installs tdd glebis tdd runs test-driven development cycles with strict context separation across subagents. Useful for writing clean features and reproducing bugs. CX Codex +1 262installs tdd-orchestrator davila7 tdd-orchestrator is a Claude Code skill that orchestrates test-driven development through red-green-refactor cycles. It coordinates multi-agent testing workflows and verifies test-first compliance. CX Codex +1 51installs tdd-workflow Affaan Mustafa tdd-workflow makes the agent write tests before code and keep coverage at 80% or higher across unit, integration and Playwright E2E suites. CX Codex +1 ★ 6,739repo stars TDD Red Phase - Write Failing Tests First official github The TDD Red Phase - Write Failing Tests First subagent pulls GitHub issue context from branch names and creates failing tests for acceptance criteria before code is written. It enforces the red stage of TDD. CX Codex +1 ★ 41,430repo stars tdd-red Seth Hobson tdd-red — a slash command that writes only tests which must fail, and leaves production code alone. The first step of TDD, when behavior needs pinning down before implementation. CX Codex +1 ★ 42,780repo stars test-audit mblode test-audit — a skill for Claude Code, Cursor, Codex and other agents that removes low-value tests from a suite down to a measured target while keeping coverage. Runs as a focused directory audit or a whole-repo campaign with a numeric goal. CX Codex +1 283installs

From the same set36

The whole set →
codex-exec codex-exec runs Codex CLI tasks directly inside Claude Code sessions. It applies proper sandboxing modes, reasoning flags, and selects between GPT-5 models. CX Codex +1 ★ 907repo stars hooks-guide The hooks-guide subagent walks you through designing a Claude Code hook, from its trigger event to its action. Use it to turn a workflow automation idea into hook files. CX Codex ★ 907repo stars ms365-tenant-manager ms365-tenant-manager — a skill for Microsoft 365 Global Administrators: tenant setup, user management, security policies, and PowerShell automation. CX Codex +1 ★ 907repo stars agents-guide agents-guide is a Claude Code subagent that asks a few questions and creates a ready-to-use Markdown file with YAML frontmatter and a system prompt for configuring a subagent. CX Codex ★ 907repo stars hook-factory hook-factory — a skill for generating production-ready Claude Code hooks via interactive Q&A or template selection. Covers 10 templates across 7 event types with auto-installation and safety checks. CX Codex +1 ★ 907repo stars build-hook build-hook generates custom Claude Code automation hooks through an interactive questionnaire with safety validation. CX Codex +1 ★ 907repo stars scrum-master-agent The scrum-master-agent skill analyzes sprint data, helps allocate work to team capacity, and creates standup and retrospective reports. It accepts data from Linear, Jira, GitHub Projects, and Azure DevOps. CX Codex +1 ★ 907repo stars aws-solution-architect aws-solution-architect picks an AWS architecture pattern for a startup project — serverless, microservices or three-tier — and estimates its monthly cost. CX Codex +1 ★ 907repo stars

Project sponsors

Companies that keep this analytics open