tdd-workflow

A coding workflow that applies test-driven development, or TDD: write a test that fails, make the smallest code change that passes, then improve the code while keeping the tests passing.

In plain words
What is it for?
Use it when building features or fixing bugs that should begin with a failing test, especially when working in small, testable steps.
Why use it?
It makes the expected behavior explicit before implementation and provides checks that help catch regressions during changes.

Skill for Claude CodeCodex

Part of the cdf plugin — 13 skills, 20 commands, 11 agents, 4 hooks shipped together

Install

Getting it into your agent

One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.

agentmods
npx agentmods add skills/drag88/claude-dev-framework/tdd-workflow
Any agent
npx skills add drag88/claude-dev-framework --skill tdd-workflow
Clone the repo
git clone --depth 1 https://github.com/drag88/claude-dev-framework

Made for: Claude Code, Codex.

Or install cdf, the plugin that ships this one along with the rest of its 13 skills, 20 commands, 11 agents, 4 hooks.

Per session 21 Skills are progressive disclosure: only the name and description are preloaded; the body loads when the skill is used.
When invoked 1,253 The whole file, excluding the scripts and references it only reads on demand.
Security scan A 0 findings. Scan, not verified.
Origin original No closer match found in the catalogue.
Token cost

What it costs to keep this loaded

Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.

ModelPer sessionOnce invoked
Fable 5 $0.00021 $0.01253
Opus 5 $0.00010 $0.00626
Sonnet 5 $0.00004 $0.00251
Haiku 4.5 $0.00002 $0.00125

Measured 2d ago against content hash 9e149ef61571, method: parsed. Prices are Anthropic first-party input rates as of 2026-08-30, from the pricing page.

Security

Grade A, and why

tdd-workflow scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 2d ago.

A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.

Nothing flagged

None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.

skills/tdd-workflow/SKILL.md · 202 lines

How it starts

The opening of the file, as written. The whole thing — 202 lines — stays where its author put it; the contents beside it link to each section on GitHub.

TDD Workflow Skill

Automatically enforce Test-Driven Development practices during implementation.

When to Activate

  • When /cdf:tdd command is invoked
  • During feature implementation when user mentions "TDD", "test-first", or "test-driven"
  • When implementing bug fixes that should start with a failing test
  • During any implementation where high code quality is required

Core Principles

RED-GREEN-REFACTOR Cycle

RED:      Write a failing test
GREEN:    Make it pass with minimal code
REFACTOR: Improve the code, keep tests green

Workflow Steps

1. Understand the Requirement

Before writing any code:

  • Clarify what behavior needs to be implemented
  • Identify inputs and expected outputs
  • Break down into small, testable units

2. Write the Failing Test (RED)

// Start with the test
describe('calculateShippingCost', () => {
  it('should return free shipping for orders over $100', () => {
    const order = { total: 150, items: [] };
    const result = calculateShippingCost(order);
    expect(result).toBe(0);
  });
});

3. Run and See It Fail

npm test -- --testPathPattern="shipping"

# Expected output:
# FAIL  src/shipping.test.ts
# ● calculateShippingCost › should return free shipping for orders over $100
#   ReferenceError: calculateShippingCost is not defined

4. Write Minimal Implementation (GREEN)

// Minimal code to pass
function calculateShippingCost(order: Order): number {
  if (order.total > 100) {
    return 0;
  }
  return 10;
}

5. Run and See It Pass

npm test -- --testPathPattern="shipping"

# Expected output:
# PASS  src/shipping.test.ts
# ✓ calculateShippingCost › should return free shipping for orders over $100

6. Refactor If Needed (REFACTOR)

// Improved version with constants
const FREE_SHIPPING_THRESHOLD = 100;
const STANDARD_SHIPPING_COST = 10;

function calculateShippingCost(order: Order): number {
  return order.total > FREE_SHIPPING_THRESHOLD
    ? 0
    : STANDARD_SHIPPING_COST;
}

Read the full file on GitHub · 202 lines

Changes

What this file has done since we first saw it

Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.

  1. 2d ago First seen · 202 lines · 21 tokens per session scan A 9e149ef61571

Subscribe to this mod's changes

tdd-workflow is a skill published in the GitHub repository drag88/claude-dev-framework (2 stars, last pushed 1mo ago), licensed MIT. It adds 21 tokens to every session and 1,253 once invoked, about $0.0001 per session on Opus 5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-31.

Related

Other skills, from other repositories

agent-integration

Run all three agent integration phases sequentially: research, write-tests, and implement using E2E-first TDD (unit tests written last). For individual phases, use /agent-integration:research, /agent-integration:write-tests, or /agent-integration:implement. Use when the user says "integrate agent", "add agent…

entireio/cli · 89 tokens

engram-testing-coverage

TDD and coverage standards for Engram. Trigger: When implementing behavior changes in any package.

Gentleman-Programming/engram · 25 tokens

code-assist

Guides implementation of code tasks using test-driven development in an Explore, Plan, Code, Commit workflow. Acts as a Technical Implementation Partner and TDD Coach — following existing patterns, avoiding over-engineering, and producing idiomatic, modern code.

mikeyobrien/ralph-orchestrator · 53 tokens

tdd

Test-driven development. Use when the user wants to build features or fix bugs test-first, mentions "red-green-refactor", or wants integration tests.

GreyDGL/PentestGPT · 33 tokens

css-design-tdd

Test-driven CSS design system modifications. Run checks before/after CSS changes to verify token usage, variable definitions, fallbacks, and consistency. Use when modifying CSS tokens, fixing design inconsistencies, or auditing CSS architecture.

xiaolai/vmark · 49 tokens

mobiai-mobile-tdd

You MUST use this before writing any implementation code for a mobile feature, bug fix, refactor, or behavior change. Tests come before implementation — no exceptions.

ArisGuimera/MobiAI-Core · 38 tokens