skills.rest
aganesy
aganesyCOMMUNITY
Explore all skills by this author →
GitHub

qfai-tdd-red

Implements failing unit and component tests for the TDD Red phase with strict ALLOWLIST scope control.

3|Updated Dec 24, 2025
Search Tags:#code quality#unit tests#testing#tdd#component tests#test-first
One-click install
npx skills add https://github.com/aganesy/QFAI --skill qfai-tdd-red
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: qfai-tdd-red
Source: https://github.com/aganesy/QFAI/tree/main/packages/qfai/assets/init/.qfai/assistant/skills/qfai-tdd-red
Command: npx skills add https://github.com/aganesy/QFAI --skill qfai-tdd-red

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill enforces the Test-Driven Development (TDD) "Red" phase by ensuring that failing tests are written before any production code is implemented, guaranteeing that tests cover the intended functionality and edge cases.

Core Features & Use Cases

  • Test-First Implementation: Focuses on writing unit and component tests that are designed to fail initially.
  • Scope Enforcement: Strictly adheres to the ALLOWLIST for changes, preventing modifications to production logic beyond what's necessary for testability.
  • Use Case: A developer needs to implement a new validation function. They use this Skill to write several failing tests that cover valid inputs, invalid inputs, and edge cases, ensuring the function's requirements are clearly defined before implementation begins.

Quick Start

Use the qfai-tdd-red skill to implement failing unit tests for the specified test ID.

Frequently Asked Questions about qfai-tdd-red

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

FAQPage Schema
How do I write failing unit tests for the TDD Red phase?▼

The Test-Driven Development Red phase requires writing failing component tests before production code to ensure requirements are clearly defined. It prevents premature implementation by enforcing strict scope guardrails and an allowlist for code modifications.

How do I prevent premature production logic implementation when writing tests?▼

Prevent premature production logic implementation by enforcing strict adherence to a defined ALLOWLIST for code modifications. This restricts changes to only what is necessary for testability, ensuring the focus remains on writing failing unit and component tests.

What is the best way to define function requirements before writing production code?▼

When your TDD Red phase tests are not working, verify that they provide explicit evidence of reproducible failing states. Ensure all code modifications strictly adhere to the defined ALLOWLIST and that no premature production logic has been implemented.

Does test-first development restrict modifications to existing production logic?▼

Yes, test-first development restricts modifications by enforcing scope guardrails and a strict ALLOWLIST. This prevents changes to production logic beyond what is absolutely necessary for testability, ensuring the Red phase remains isolated.

Related Skills

Explore More Software Engineering Skills→
Ying-Kai-LiaoYing-Kai-Liao
1

tdd-workflow

Enforce test-driven development workflows with 80%+ coverage across unit, integration, and end-to-end tests.

Community
Advanced
nicolaeinicolaei

running-tdd-cycle

Coordinate the complete TDD RED-GREEN-REFACTOR workflow for Python development.

Community
Intermediate
Kushal9889Kushal9889

tdd

Implement a Test-Driven Development workflow with red-green-refactor cycles.

Community
Intermediate
artofrawrartofrawr
1

react-web

Enforce test-first workflows for React UI components, hooks, and pages.

Community
Intermediate