tdd-workflow

Enforce test-first development with 80% coverage across unit, integration, and E2E tests.

Updated Jan 20, 2026
One-click install
npx skills add https://github.com/Xyxy1722/Agent-skills --skill tdd-workflow-xyxy1722
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd-workflow
Source: https://github.com/Xyxy1722/Agent-skills/tree/main/develop/tdd-workflow
Command: npx skills add https://github.com/Xyxy1722/Agent-skills --skill tdd-workflow-xyxy1722

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill ensures all code development adheres to Test-Driven Development (TDD) principles, guaranteeing high test coverage and robust software quality.

Core Features & Use Cases

  • Mandatory Test-First Approach: Enforces writing tests before implementation.
  • Comprehensive Coverage: Requires 80%+ coverage across unit, integration, and E2E tests.
  • Structured Workflow: Guides developers through user journeys, test generation, implementation, and verification.
  • Use Case: When starting a new feature, use this skill to ensure tests are written first, guiding the implementation and verifying quality.

Quick Start

Use the tdd-workflow skill to develop new features following test-driven development.

Frequently Asked Questions about tdd-workflow

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I enforce a test-driven development workflow for new features?

To enforce a test-driven development workflow, you must mandate test creation before code implementation, requiring a minimum of 80% coverage across unit, integration, and E2E tests. This structured approach guides developers from user journey definition to final verification.

What is the minimum code coverage required when following a strict TDD lifecycle?

The minimum code coverage required when following a strict TDD lifecycle is 80%. This coverage must span across unit tests, integration tests, and end-to-end tests, specifically including edge cases and error scenarios to guarantee robust software quality.

How do I structure tests before implementation to ensure edge cases are covered?

Structuring tests before implementation involves defining user journeys first, then generating tests that cover edge cases and error scenarios. This test-first approach ensures the code written afterwards meets the 80% coverage requirement and handles anticipated errors.

Can I use a test-first approach for both unit and integration testing?

Yes, you can use a test-first approach for both unit and integration testing. The workflow mandates writing tests before implementation across all test types, including unit, integration, and end-to-end tests, to achieve comprehensive 80% code coverage.

Does test-driven development work for refactoring existing code with low coverage?

Test-driven development for refactoring existing code requires defining user journeys and generating tests before implementation. By mandating 80% coverage across unit, integration, and E2E tests, it ensures refactored code maintains robust quality and handles edge cases properly.

Why does my TDD workflow fail to catch integration edge cases and error scenarios?

A TDD workflow fails to catch integration edge cases when it does not explicitly mandate testing for these scenarios before implementation. Achieving 80% coverage requires defining user journeys and generating tests that specifically target error scenarios across all test levels.