tdd-workflow

Enforce test-first delivery with failing tests before implementation and 80 percent coverage.

Updated May 14, 2026
One-click install
npx skills add https://github.com/WUIX69/e-lock --skill tdd-workflow-wuix69
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd-workflow
Source: https://github.com/WUIX69/e-lock/tree/main/.agent/.agents/skills/tdd-workflow
Command: npx skills add https://github.com/WUIX69/e-lock --skill tdd-workflow-wuix69

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill prevents fragile, untested code changes by forcing a test-first workflow for features, bug fixes, and refactors, so implementation stays safe and predictable.

Core Features & Use Cases

  • Test-First Development: Write failing tests before any implementation to define expected behavior clearly.
  • Comprehensive Coverage: Cover unit, integration, and E2E scenarios with validation for edge cases, errors, and boundaries.
  • Practical Use Cases: Ideal for adding API endpoints, building UI components, refactoring logic, or stabilizing regressions while keeping coverage high and outcomes verifiable.

Quick Start

Use the tdd-workflow skill to plan the change with failing tests first, then implement the code until all tests pass and coverage reaches the required threshold.

Frequently Asked Questions about tdd-workflow

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

FAQPage Schema
How do I enforce test-first development for new features and bug fixes?

Test-first development is enforced by requiring failing tests before implementation. This workflow applies to new features, bug fixes, and refactors, ensuring expected behavior is defined clearly before code changes are made.

What's the best way to maintain code coverage during refactoring?

Maintaining code coverage during refactoring requires validating edge cases and verifying coverage thresholds. The workflow enforces 80 percent or higher coverage, keeping logic changes safe and outcomes verifiable while preventing fragile code.

How do I write failing tests for API endpoints and UI components?

Writing failing tests for API endpoints and UI components involves defining expected behavior before implementation. This test-first approach covers unit, integration, and E2E scenarios, validating boundaries and errors across critical browser workflows.

Can I use this test-driven development workflow for both unit and E2E testing?

Yes, this test-driven development workflow supports unit, integration, and E2E testing. It applies to critical browser workflows and API endpoints, requiring failing tests before implementation and ensuring 80 percent or higher coverage verification.

Why does test-first delivery prevent fragile code changes?

Test-first delivery prevents fragile code changes by forcing a test workflow before implementation. This makes software changes predictable and safe by defining expected behavior upfront and requiring comprehensive edge-case validation.

When do I need failing tests before implementation?

Failing tests before implementation are needed when adding API endpoints, building UI components, refactoring logic, or stabilizing regressions. This test-first workflow ensures 80 percent or higher coverage and edge-case validation across all software changes.