tdd-engine

Coordinates Grader, Redactor, and Reflector phases for TDD task-card workflows with adaptive routing and strict state transitions.

133|9|Updated Mar 26, 2026
One-click install
npx skills add https://github.com/lync-cyber/CataForge --skill tdd-engine
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd-engine
Source: https://github.com/lync-cyber/CataForge/tree/main/.cataforge/skills/tdd-engine
Command: npx skills add https://github.com/lync-cyber/CataForge --skill tdd-engine

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill coordinates a disciplined RED → GREEN → REFACTOR TDD workflow so complex implementation tasks can be delivered reliably without losing test coverage or context.

Core Features & Use Cases

  • TDD phase orchestration: Guides orchestrators through RED, GREEN, and conditional REFACTOR execution for task cards.
  • Adaptive execution modes: Supports standard, light-dispatch, light-inline, and prototype-inline paths based on task size and risk.
  • Parallel sprint handling: Helps manage independent tasks within the same sprint group while preserving serialization rules for refactoring.
  • Use case: A team implementing a new feature can use this Skill to generate failing tests first, produce the smallest passing implementation, and decide whether refactoring is required.

Quick Start

Ask the AI to execute the TDD engine for task T-001 and produce the test plan, minimal implementation path, and refactor decision.

Frequently Asked Questions about tdd-engine

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

FAQPage Schema
How do I orchestrate test-driven development phases for complex implementation tasks?

Test-driven development orchestration coordinates RED, GREEN, and conditional REFACTOR phases to guide task-card driven implementation workflows. It applies phase-specific prompts and controlled state transitions to deliver complex features reliably without losing test coverage.

What is the best way to manage red-green-refactor cycles when handling parallel sprint tasks?

Red-green-refactor cycles for parallel sprint tasks are managed through adaptive routing between standard, light-dispatch, light-inline, and prototype-inline execution modes. This approach preserves serialization rules for refactoring while allowing independent tasks within the same sprint group to proceed.

How does adaptive execution routing work for test-driven development workflows?

Adaptive execution routing selects between standard, light-dispatch, light-inline, and prototype-inline paths based on task size and risk. It applies phase-specific prompts, acceptance criteria handling, and test command selection to control state transitions during test-driven development.

Can I use this test-driven development workflow for task-card driven implementation without external dependencies?

Yes, this test-driven development workflow operates without external dependencies. It uses internal references to manage phase-specific prompts, acceptance criteria handling, and test command selection for task-card driven implementation workflows requiring reliable delivery.

When should I trigger a conditional refactor phase during test-driven development?

The conditional refactor phase triggers during test-driven development after the GREEN phase produces the smallest passing implementation. It evaluates whether refactoring is required based on the task card's acceptance criteria and the current state of the implementation.

Why does my test-driven development implementation lose context during phase transitions?

Test-driven development implementations lose context during phase transitions when lacking controlled state transitions and phase-specific prompts. This orchestration engine enforces strict RED, GREEN, and REFACTOR state management to preserve test coverage and context throughout delivery.