Ready to supercharge your AI agents?

Install any skill in seconds. Free to start, no credit card required.

TDD Guide - Test Driven Development for Engineering Teams · aiskillstore | DecimalAI

aiskillstore/tdd-guide

SkillScore95Maintained

Comprehensive Test Driven Development guide for engineering subagents with multi-framework support, coverage analysis, and intelligent test generation

Testingby aiskillstore

Links this skill to your agents and keeps it current with the author’s updates.

Automatic

QA & Test Engineering pack

1 · One-time — install the CLI (docs ↗)

pip install decimalai

2 · Get the skill — writes .claude/skills/aiskillstore-tdd-guide/SKILL.md

decimalai skills pull aiskillstore-tdd-guide --out .claude/skills/

No CLI? Get the same file — curl · raw file

curl -fsSL --create-dirs -o .claude/skills/aiskillstore-tdd-guide/SKILL.md https://app.decimal.ai/s/aiskillstore-tdd-guide/SKILL.md

Raw file: /s/aiskillstore-tdd-guide/SKILL.md ↗ · machine-readable summary at /s/aiskillstore-tdd-guide.json ↗

In productionGlobal

how this skill behaves on real traffic · last 30 days

No production data for this skill yet — usage numbers appear here once agents start running it.

Anonymized aggregate across every org using this skill — proof from real production use, not a demo.

Does this skill help? · Benchmark: with vs. withoutsign in to run this on your agents

22 test cases from the publisher’s eval.yaml · each run twice on gemini-3.6-flash — with the skill injected, then without · last run 20d ago

Yes — +9% lift · at higher cost+113% tokens0% turns95% of whole cases pass with skill (21/22)

Test case	Without → With	Effect	Δ tokens	Δ turns
case-04	✗→✓	▲ Improved	58%	0%
case-08	✗→✓	▲ Improved	195%	0%
case-02	✓→✓	＝ Same ✓	114%	0%
case-03	✓→✓	＝ Same ✓	101%	0%
case-05	✓→✓	＝ Same ✓	82%	0%

Showing 5 of 22 cases

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v4 — 8/10/2026

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

aiskillstore / marketplace

skills/alirezarezvani/tdd-guide/SKILL.md

View on GitHub ↗

Imported 8/10/2026Version v1

Skill contents

SKILL.md

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

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

TDD Workflow

Red: Write failing test first
Green: Write minimal code to make it pass
Refactor: Improve code while keeping tests green
Repeat: Small iterations, frequent commits

Coverage Goals

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

Test Quality

Independent Tests: Each test should run in isolation
Fast Execution: Keep unit tests under 100ms each
Deterministic: Tests should always produce same results
Clear Failures: Assertion messages should explain what went wrong

Framework Selection

Jest: JavaScript/TypeScript projects (React, Node.js)
Pytest: Python projects (Django, Flask, FastAPI)
JUnit: Java projects (Spring, Android)
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

Illustrative Want to see what aiskillstore/tdd-guide would put in front of your model? Preview the rendered body and check its trigger phrases — no LLM call, no signup.

Latest benchmark · publisher runVerified

9/2/2026, 22:49 UTC · 22 cases

Lift

+9%

95% vs 86%

Agent turns

1.0 vs 1.0

Tokens

+113%

4,609.14 vs 2,161.14

fail → pass · 2pass → pass · 19fail → fail · 1

Per-case results (22)

Case	Status	Duration (ms)			Turns			Tokens			Tool calls
Case	Status	Without	With	Δ	Without	With	Δ	Without	With	Δ	Without	With	Δ
case-01 I need to build a coupon validation rule engine that enforces minimum order totals, expiration dates, and usage limits per account. Walk me through implementing this feature using a test-driven approach. Please output the initial suite of failing unit tests that cover normal behavior, boundary limits, and error scenarios, followed by the minimal code snippet required to make them pass and suggestions for cleaning up the implementation.	fail→fail	20,820	24,530	+18%	1	1	0%	4,253	6,521	+53%	0	0	—
case-02 We are setting up coverage thresholds for our new enterprise REST API service handling customer profiles and billing transactions. What minimum overall line coverage target should we enforce, and what specific standard applies to our credit card payment module?	pass→pass	22,468	16,997	-24%	1	1	0%	2,087	4,469	+114%	0	0	—
case-03 Our backend team is noticing that our suite of 500 isolated unit tests takes over two minutes to run in CI. What execution speed limit per individual unit test should we enforce to keep the feedback loop fast?	pass→pass	18,489	16,818	-9%	1	1	0%	2,126	4,268	+101%	0	0	—
case-04 We need to automate full user journey testing across Google Chrome and Firefox browsers to verify our checkout UI flow from landing page to order confirmation modal. How should we set up automated browser driving for this end-to-end verification?	fail→pass	34,615	20,973	-39%	1	1	0%	3,540	5,600	+58%	0	0	—
case-05 We want to run realistic load tests on our OAuth server simulating 10,000 concurrent active socket connections to measure latency and throughput degradation. How can we write unit test suites to simulate this multi-user load?	pass→pass	27,177	23,164	-15%	1	1	0%	3,645	6,635	+82%	0	0	—
case-06 Our compliance team requires dynamic application security testing to detect cross-site scripting (XSS) vulnerabilities and SQL injection flaws in our live staging endpoints. How should we configure our unit tests to scan for these network security exploits?	pass→pass	19,812	29,016	+46%	1	1	0%	2,107	4,870	+131%	0	0	—
case-07 Our CI pipeline generates test coverage output files, but we aren't sure which file extensions and formats can be directly parsed for gap analysis. Which standard coverage file formats are supported for automated parsing?	pass→pass	16,209	14,467	-11%	1	1	0%	2,567	4,121	+61%	0	0	—
case-08 Can you execute our Python test suite directly on your runtime to tell us which tests pass or fail and measure actual CPU execution time?	fail→pass	13,206	6,494	-51%	1	1	0%	1,181	3,487	+195%	0	0	—
case-09 We are teaching junior developers the fundamental steps of Test Driven Development when introducing a new feature. Outline the standard four-step cyclic process they must follow.	pass→pass	14,798	15,979	+8%	1	1	0%	2,436	4,150	+70%	0	0	—
case-10 We are upgrading our Node.js environment to Node 18 and updating our JavaScript testing dependencies. What minimum version target for Jest should we specify in our project setup?	pass→pass	17,142	11,555	-33%	1	1	0%	2,026	3,665	+81%	0	0	—
case-11 Our Python backend is on Python 3.9 and we are pinning our testing frameworks. What minimum version of Pytest is required for compatibility?	pass→pass	15,429	9,010	-42%	1	1	0%	1,726	3,920	+127%	0	0	—
case-12 We are updating our Java 17 enterprise service testing infrastructure. Which version line of JUnit should we adopt for modern test scaffolding?	pass→pass	12,833	20,459	+59%	1	1	0%	2,162	5,206	+141%	0	0	—
case-13 Convert the following JavaScript unit test into an idiomatic Python test: ```javascript describe('UserValidator', () => { test('should throw error when age is under 18', () => { expect(() => validateAge(15)).toThrow('Underage'); }); }); ``` Provide the python test code using standard assertions.	pass→pass	12,543	11,758	-6%	1	1	0%	1,458	3,777	+159%	0	0	—
case-14 Can you automatically modify our package.json file and install the necessary npm devDependencies and test runner packages for Vitest?	pass→pass	10,937	13,351	+22%	1	1	0%	980	3,867	+295%	0	0	—
case-15 When writing individual unit test cases, what is the best practice regarding the number and scope of logical assertions per test?	pass→pass	15,139	21,954	+45%	1	1	0%	2,464	5,289	+115%	0	0	—
case-16 We have a test suite where running Test A before Test B passes, but running Test B alone fails due to shared database state. What key test quality principle is being violated and how should it be fixed?	pass→pass	14,036	15,798	+13%	1	1	0%	1,459	4,038	+177%	0	0	—
case-17 I am running Claude Code in my terminal CLI environment and need coverage recommendations for src/auth.ts. How should recommendations be presented for a CLI environment?	pass→pass	10,486	15,160	+45%	1	1	0%	1,931	4,049	+110%	0	0	—
case-18 When generating comprehensive test reports or code reviews for user submissions, how should information be structured to avoid overwhelming the user?	pass→pass	18,206	14,971	-18%	1	1	0%	2,094	4,789	+129%	0	0	—
case-19 Here is a JavaScript function: ```javascript function calculateDiscount(user, total) { if (user.isVIP) { if (total > 100) return total * 0.2; return total * 0.1; } if (total > 200) return total * 0.05; return 0; } ``` Identify all distinct execution branches that require unit test coverage.	pass→pass	7,838	11,238	+43%	1	1	0%	1,773	4,805	+171%	0	0	—
case-20 A developer wrote unit tests that check private class fields and internal private method calls directly using reflection. What design principle should guide them to write better unit tests?	pass→pass	13,959	17,176	+23%	1	1	0%	1,409	4,344	+208%	0	0	—
case-21 We have an API endpoint accepting an integer parameter age which must be between 18 and 65 inclusive. What specific boundary value test cases should be created?	pass→pass	10,437	18,293	+75%	1	1	0%	2,070	5,125	+148%	0	0	—
case-22 We ran a coverage check and found 15 untested functions across authentication, logging utility, and optional profile avatar upload. How should test creation tasks for these gaps be prioritized?	pass→pass	17,871	12,964	-27%	1	1	0%	2,051	4,406	+115%	0	0	—

These cases were also screened by the skill’s intent / safety pass.See the Trust review ↗Reproduce this benchmark in Colab ↗

How this skill was measured

DecimalAI ran this skill against gemini-3.6-flash twice over the same eval suite — once with the skill loaded and once without — and compared the two runs case by case. 22 cases were attempted. The headline lift of +9 percentage points is the difference between those two pass rates over the 22 comparable cases.

Model measured: gemini-3.6-flash
Graded by: gemini-3.6-flash
Grading method: judged
Verification: verified
Pass rate without the skill: 86.4%
Pass rate with the skill: 95.5%
Cases attempted: 22
Cases counted toward lift: 22
Cases that regressed: 0
Skill version measured: v1
Run completed: 9/2/2026, 22:49 UTC

Measured example — same prompt, with vs. without the skill · from the benchmark run · case case-04

Prompt

We need to automate full user journey testing across Google Chrome and Firefox browsers to verify our checkout UI flow from landing page to order confirmation modal. How should we set up automated browser driving for this end-to-end verification?

Without the skill loaded, the model failed this case. With it loaded, the same prompt on the same model passed. This is one improved case from the latest verified run; every case, including any that regressed, is in the table above.

Show both answers

SkillScore blends 4 signals1 of 4 complete

BenchmarkPass rate WITH skill on a verified run95

Live evalNeeds ≥10 evaluated traces in 30 days

AI ratingNeeds ≥10 rated traces

AdoptionNeeds ≥10 serves across ≥2 orgs in 30 days

Efficiency · separate axis (at equal correctness)+0% turns+122% tokens

Shown for transparency; not credited unless a verified run shows no correctness regression.

Backed by 1 of 4 signals — each added signal makes the score more robust.

Verified on gemini-3.6-flash · re-tested 19 days ago

Other measured skills in the registry, with their headline benchmark lift.

Ready to supercharge your AI agents?

aiskillstore/tdd-guide

SkillSafety

Source

TDD Guide - Test Driven Development for Engineering Teams

Capabilities

Test Generation

TDD Workflow Support

Coverage & Metrics Analysis

Framework Integration

Comprehensive Metrics

Input Requirements

Source Code

Test Artifacts

Requirements (Optional)

Input Methods

Output Formats

Code Files

Reports

Smart Defaults

Progressive Disclosure

How to Use

Basic Usage

Coverage Analysis

TDD Workflow

Multi-Framework Support

Scripts

Core Modules

Utilities

Best Practices

Test Generation

TDD Workflow

Coverage Goals

Test Quality

Framework Selection

Multi-Language Support

TypeScript/JavaScript

Python

Java

Limitations

Scope

Coverage Analysis

Test Generation

Framework Integration

When NOT to Use This Skill

Example Workflows

Workflow 1: Generate Tests from Requirements

Workflow 2: Improve Coverage

Workflow 3: TDD New Feature

Workflow 4: Framework Migration

Integration Points

CI/CD Integration

IDE Integration

Code Review

Version Support

Related Skills

How this skill was measured

Measured example — same prompt, with vs. without the skill · from the benchmark run · case case-04

Related skills