# Tdd

> Enforce strict Test-Driven Development (TDD) using the red-green-refactor cycle. Use when writing unit tests, practicing test-first development, applying TDD discipline, or implementing features via red-green-refactor workflows.

- **Type:** Skill
- **Install:** `agentstack add skill-merozemory-oh-my-droid-tdd`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [MeroZemory](https://agentstack.voostack.com/s/merozemory)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [MeroZemory](https://github.com/MeroZemory)
- **Source:** https://github.com/MeroZemory/oh-my-droid/tree/main/skills/tdd

## Install

```sh
agentstack add skill-merozemory-oh-my-droid-tdd
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# TDD Mode

## The Iron Law

**NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST**

Write code before test? DELETE IT. Start over. No exceptions.

## Red-Green-Refactor Cycle

### 1. RED: Write Failing Test
- Write test for the NEXT piece of functionality
- Run test - MUST FAIL
- If it passes, your test is wrong

### 2. GREEN: Minimal Implementation
- Write ONLY enough code to pass the test
- No extras. No "while I'm here."
- Run test - MUST PASS

### 3. REFACTOR: Clean Up
- Improve code quality
- Run tests after EVERY change
- Must stay green

### 4. REPEAT
- Next failing test
- Continue cycle

## Enforcement Rules

| If You See | Action |
|------------|--------|
| Code written before test | STOP. Delete code. Write test first. |
| Test passes on first run | Test is wrong. Fix it to fail first. |
| Multiple features in one cycle | STOP. One test, one feature. |
| Skipping refactor | Go back. Clean up before next feature. |

## Commands

Before each implementation:
```bash
npx jest --watchAll  # Should have ONE new failure
# or: npx vitest run, pytest, go test ./...
```

After implementation:
```bash
npx jest --watchAll  # New test should pass, all others still pass
```

## Worked Example: Adding a `capitalize` Function

### RED Phase — Write the Failing Test

```js
// src/strings.test.js
const { capitalize } = require('./strings');

describe('capitalize', () => {
  it('should uppercase the first letter and lowercase the rest', () => {
    expect(capitalize('hello')).toBe('Hello');
  });

  it('should handle single character strings', () => {
    expect(capitalize('h')).toBe('H');
  });

  it('should return empty string for empty input', () => {
    expect(capitalize('')).toBe('');
  });
});
```

Run tests — they fail because `strings.js` does not export `capitalize`:
```
FAIL  src/strings.test.js
  ● capitalize › should uppercase the first letter and lowercase the rest
    TypeError: capitalize is not a function
```

### GREEN Phase — Minimal Implementation

```js
// src/strings.js
function capitalize(str) {
  if (!str) return '';
  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
}

module.exports = { capitalize };
```

Run tests — all three pass:
```
PASS  src/strings.test.js
  capitalize
    ✓ should uppercase the first letter and lowercase the rest
    ✓ should handle single character strings
    ✓ should return empty string for empty input
```

### REFACTOR Phase — Clean Up

Extract a guard clause for clarity, ensure tests still pass:

```js
function capitalize(str) {
  if (str.length === 0) return '';
  return str[0].toUpperCase() + str.slice(1).toLowerCase();
}
```

Tests still green. Move to the next failing test.

## Output Format

When guiding TDD:

```
## TDD Cycle: [Feature Name]

### RED Phase
Test: [test code]
Expected failure: [what error you expect]
Actual: [run result showing failure]

### GREEN Phase
Implementation: [minimal code]
Result: [run result showing pass]

### REFACTOR Phase
Changes: [what was cleaned up]
Result: [tests still pass]
```

**Remember:** The discipline IS the value. Shortcuts destroy the benefit.

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [MeroZemory](https://github.com/MeroZemory)
- **Source:** [MeroZemory/oh-my-droid](https://github.com/MeroZemory/oh-my-droid)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-merozemory-oh-my-droid-tdd
- Seller: https://agentstack.voostack.com/s/merozemory
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.