tdd

Automate test-driven development workflows by enforcing red-green-refactor cycles.

40|9|Updated Jan 4, 2026
One-click install
npx skills add https://github.com/akillness/jeo-skills --skill tdd-akillness
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tdd
Source: https://github.com/akillness/jeo-skills/tree/main/.agent-skills/tdd
Command: npx skills add https://github.com/akillness/jeo-skills --skill tdd-akillness

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Define and enforce observable behavior early by driving development with tests, reducing risk of regression and brittle implementations.

Core Features & Use Cases

  • Vertical-slice workflow: drive minimal implementation from a single test, then expand.
  • Tracer bullets: write the initial failing test to validate the intended behavior.
  • Incremental refactor cycle: continuously refine design after each passing test for better maintainability.

Quick Start

Run the tracer bullet workflow to write the first failing test and then implement the minimal code to pass it.

Frequently Asked Questions about tdd

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

FAQPage Schema
How do I start test-driven development with a red-green-refactor cycle?

Start test-driven development by writing a tracer bullet—a single failing test that defines the intended behavior through a public interface, then implement the minimal code required to pass it before refactoring.

What is the best way to enforce observable behavior when building new features?

Drive development with tests-first discipline by codifying planning, incremental loops, and validation checks to define and enforce observable behavior early, reducing the risk of regression and brittle implementations.

Can I use test-driven development workflows across language-agnostic codebases?

Yes, these test-driven development workflows are applicable across language-agnostic codebases, guiding design through observable behavior via public interfaces without requiring specific framework dependencies.

How does vertical-slice workflow drive minimal implementation from a single test?

A vertical-slice workflow drives minimal implementation from a single test, then expands outward incrementally, guiding software design through observable behavior verified via public interfaces.

When should I not use test-driven development for bug fixes?

Avoid test-driven development when observable behavior cannot be verified through public interfaces, as the workflow relies on validating tracer bullets and incremental refactor cycles to reduce regression risk.