jds-tdd

Enforce a RED-GREEN-REFACTOR TDD workflow for software implementation tasks.

13|Updated Mar 24, 2026
One-click install
npx skills add https://github.com/josipmusa/jds --skill jds-tdd
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: jds-tdd
Source: https://github.com/josipmusa/jds/tree/main/skills/jds-tdd
Command: npx skills add https://github.com/josipmusa/jds --skill jds-tdd

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill enforces the RED-GREEN-REFACTOR TDD cycle during implementation, ensuring tests drive coding discipline and preventing post-hoc testing.

Core Features & Use Cases

  • Enforces TDD cycle (RED, GREEN, REFACTOR) for every implementation task.
  • Ensures tests are written before implementation and maintained.
  • Tracks progress and enforces rule that code written only after failing test.

Quick Start

Start by writing a failing test for the new behavior, then implement the minimum code to pass, and refactor while keeping all tests green.

Frequently Asked Questions about jds-tdd

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

FAQPage Schema
How do I enforce strict TDD cycles during software implementation?

To enforce strict TDD cycles, you must explicitly adhere to the RED-GREEN-REFACTOR discipline, ensuring tests drive coding by requiring a failing test before any production code is written. This prevents post-hoc testing and maintains code quality.

What is the RED-GREEN-REFACTOR workflow in test-driven development?

The RED-GREEN-REFACTOR workflow is a test-driven development process where you first write a failing test (RED), implement the minimum code to pass it (GREEN), and then refactor the code while keeping all tests green. This enforces strict coding discipline.

How do I start implementing a feature using rigid TDD process enforcement?

To start implementing a feature with rigid TDD process enforcement, begin by writing a failing test for the new behavior. Then, implement the minimal code required to pass the test, and finish with a final refactoring pass to verify and clean up the production code.

Can I write production code before tests when using a TDD workflow?

No, you cannot write production code before tests in a strict TDD workflow. The process enforces a rule that code is written only after a failing test exists, ensuring that tests always precede implementation and driving code quality through formal cycle tracking.

Does TDD process enforcement apply to any feature development task?

Yes, TDD process enforcement applies to any feature development task where tests must precede production code. It tracks progress through a formal RED-GREEN-REFACTOR cycle, ensuring explicit adherence to testing discipline for every implementation task.

Why does test-driven development require a final refactor pass?

Test-driven development requires a final refactor pass to clean up and optimize the production code while ensuring all tests remain green. This step maintains code quality and verifies that the minimal implementation still functions correctly after structural improvements.