tdd-workflow

Convert requirements into executable tests using the RED-GREEN-REFACTOR cycle.

Updated Mar 24, 2026
One-click install
npx skills add https://github.com/Icebane84/Synarche_Workshop --skill tdd-workflow-icebane84
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd-workflow
Source: https://github.com/Icebane84/Synarche_Workshop/tree/main/.agent/skills/qa/tdd-workflow
Command: npx skills add https://github.com/Icebane84/Synarche_Workshop --skill tdd-workflow-icebane84

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill helps you avoid fragile, error-prone code changes by forcing requirements to become executable tests before implementation.

Core Features & Use Cases

  • RED-GREEN-REFACTOR Discipline: Turn failing tests into passing behavior, then improve structure without breaking correctness, ideal for incremental development.
  • Test Design Rules: Focus tests on behavior, edge cases, and error states to reduce ambiguity and increase coverage during implementation.
  • AAA Test Structure: Standardize tests with Arrange, Act, and Assert so results are clear, repeatable, and easy to maintain.

Use Case: When fixing a bug or building a new feature, write a test that demonstrates the desired behavior, implement the minimum code to satisfy it, then refactor while keeping all tests green.

Quick Start

Use the tdd-workflow skill to guide your RED-GREEN-REFACTOR cycle for the feature you are implementing or the defect you are fixing.

Frequently Asked Questions about tdd-workflow

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

FAQPage Schema
How do I use Test-Driven Development to convert requirements into executable tests?

Test-Driven Development converts requirements into executable tests by applying the RED-GREEN-REFACTOR cycle. You first write a failing test demonstrating desired behavior, implement minimal code to pass it, then refactor while keeping all tests green.

What is the best way to structure unit tests for behavior and edge cases?

The best way to structure unit tests is using the AAA (Arrange, Act, Assert) organization. This standardizes tests to focus on behavior, edge cases, and error states, making results clear, repeatable, and easy to maintain during implementation.

How do I fix a bug using the RED-GREEN-REFACTOR cycle?

To fix a bug using the RED-GREEN-REFACTOR cycle, write a failing test that demonstrates the defect or desired behavior. Implement the minimum code required to turn the failing test green, then refactor the structure without breaking correctness.

Does Test-Driven Development work for building new features and complex logic?

Yes, Test-Driven Development works for building new features and complex logic. It structures tests around behavior and error states, enforcing YAGNI-driven minimal implementation to reduce ambiguity and increase coverage throughout incremental development.

When should I not use Test-Driven Development for software design?

You should reconsider Test-Driven Development for software design when requirements are highly ambiguous and cannot be structured into executable tests, as the process depends on defining clear behavior, edge cases, and error states before implementation.

Why does the TDD workflow enforce YAGNI-driven minimal implementation?

The TDD workflow enforces YAGNI-driven minimal implementation to prevent over-engineering. By writing only the code needed to satisfy the current failing test, you avoid unnecessary complexity and keep the test suite maintainable.