TDD Skill for Agents: Red-Green-Refactor Without the Excuses

Where this fits

You're building an agent that fixes a bug in a Python service. It patches the code, runs the tests, and declares victory—but the test suite was already passing because the agent never added a test for the regression. The real problem: without a failing test first, the agent doesn't know if its fix actually addresses the root cause. The test-driven-development skill forces agents to write a test, watch it fail, then implement the minimal change—closing that gap between "code runs" and "code is correct."

Why agents benefit

• Verifies intent before code: By writing the test first, the agent proves it understands the expected behavior before touching implementation, reducing hallucinated fixes.
• Eliminates false positives: The "watch it fail" step ensures the test actually exercises the broken path—not a tautology or a test of the framework.
• Keeps changes minimal: The green step forces the agent to write the smallest change that passes, preventing scope creep and unintended side effects.
• Makes refactoring safe: Agents can clean up code with confidence because the red-green cycle guarantees behavioral coverage.
• Improves traceability: Each feature or bugfix leaves a test artifact, making agent reasoning auditable and future changes safer.

Practical scenarios

Bugfix in a legacy module

An agent is asked to fix a date-parsing bug. Without TDD, it might adjust the regex and run the existing suite. With the skill, it writes a test for the specific malformed input, watches it fail, then patches the parser—ensuring the fix is targeted and regression-proof.

Adding a new API endpoint

When building a new endpoint, the agent writes a contract test first (status code, response shape, error handling). The test fails because the route doesn't exist. The agent then implements the minimal route and handler, then refactors shared validation logic—keeping the test green throughout.

Refactoring with behavior changes

An agent is asked to split a monolithic function. It writes tests for the current output, watches them pass, then refactors. If any behavior drifts, the tests catch it immediately. The skill also flags when refactoring doesn't need TDD (e.g., pure formatting), avoiding unnecessary overhead.

Add it to your agent workflow

Install with:

npx skills add peintune/runjam --skill test-driven-development

Then in your agent's system prompt, reference the skill before any implementation task:

- For features/bugfixes: always use test-driven-development
- Process: red → green → refactor
- Skip only for config/docs/formatting

This skill pairs well with other design-creative skills. For a deeper look at how it fits into an agent's decision loop, see the skill page on OpenAgentSkill.

Compare before adopting

Evaluate this skill against your current workflow:

• Quality signals: Does your agent already produce tests? If so, are they written after code (weaker) or before (stronger)?
• Maintenance freshness: Check the GitHub repo for recent commits and issues—a stale skill may conflict with newer agent frameworks.
• Alternatives: Compare with property-based testing or snapshot testing if your domain needs them.
• Workflow fit: Does your agent already have a testing step? This skill enforces ordering, not just presence—make sure your orchestration can support the red-green-refactor loop.

Why it is worth tracking

This skill sits at 127 stars and is actively maintained by peintune. Its core principle—"if you didn't watch the test fail, you don't know if it tests the right thing"—is a strong quality signal because it targets the most common failure mode in AI-generated code: false confidence. Track it if you're building agents that modify code autonomously. Re-evaluate when your agent's test infrastructure changes or when you need stricter validation for critical paths.