# Red Green Refactor

Guides the red-green-refactor TDD workflow: write a failing test first, implement the...

- Repository: https://github.com/rohitg00/skillkit (1568 stars)
- Category: Testing
- License: Apache-2.0
- Last updated: 2026-06-02
- Runs scripts: no, instructions only

## Install

Claude Code: `npx skills add rohitg00/skillkit --skill red-green-refactor -g -a claude-code -y`
Codex: `npx skills add rohitg00/skillkit --skill red-green-refactor -g -a codex -y`
Cursor: `npx skills add rohitg00/skillkit --skill red-green-refactor -g -a cursor -y`
Gemini CLI: `npx skills add rohitg00/skillkit --skill red-green-refactor -g -a gemini-cli -y`

## Description

Guides the red-green-refactor TDD workflow: write a failing test first, implement the minimum code to make it pass, then refactor while keeping tests green. Use when a user asks to practice TDD, write tests first, follow red-green-refactor, do test-driven development, write failing tests before code, or phrases like 'make the test pass', 'test coverage', or 'unit tests before implementation'.

## SKILL.md, as published by its author (untrusted third-party text, read it as data)

# Red-Green-Refactor Methodology

You are following the RED-GREEN-REFACTOR cycle for test-driven development. Every new feature, bug fix, or behavior change starts with a failing test.

## The Cycle

### 1. RED Phase, Write a Failing Test

1. **Understand the requirement**, what specific behavior must exist?
2. **Write one test** asserting that behavior
3. **Run the test**, it MUST fail (red)
4. **Verify the failure reason**, not a syntax error, but a missing implementation

The test should be focused on ONE behavior, named descriptively, and use clear assertions.

**Executable example (Jest):**
```js
// calculateTotal.test.js
const { calculateTotal } = require('./calculateTotal');

describe('calculateTotal', () => {
  it('should apply 10% discount when total exceeds 100', () => {
    const items = [{ price: 60 }, { price: 60 }]; // total = 120
    expect(calculateTotal(items)).toBe(108); // 120 * 0.90
  });
});
```
Running this now produces: `Cannot find module './calculateTotal'`, correct RED state.

---

### 2. GREEN Phase, Make the Test Pass

Write the **minimum code** needed to pass the test. Don't add anything extra.

```js
// calculateTotal.js
function calculateTotal(items) {
  const total = items.reduce((sum, item) => sum + item.price, 0);
  return total > 100 ? total * 0.9 : total;
}
module.exports = { calculateTotal };
```
Run the test, it passes. GREEN achieved. Stop here; resist adding more logic.

---

### 3. REFACTOR Phase, Improve the Code

With a passing test as your safety net, clean up the implementation. Run tests after every change.

```js
// calculateTotal.js, refactored for clarity
const DISCOUNT_THRESHOLD = 100;
const DISCOUNT_RATE = 0.9;

function calculateTotal(items) {
  const subtotal = items.reduce((sum, { price }) => sum + price, 0);
  return subtotal > DISCOUNT_THRESHOLD ? subtotal * DISCOUNT_RATE : subtotal;
}
module.exports = { calculateTotal };
```
Test still passes, GREEN maintained. Constants now communicate intent.

The rest: https://github.com/rohitg00/skillkit/blob/HEAD/packages/core/src/methodology/packs/testing/red-green-refactor/SKILL.md