rc-tdd

Guides test-driven development through red-green cycles at agreed interface seams.

19|1|Updated Jun 27, 2026
One-click install
npx skills add https://github.com/rodolfochicone/rc-project --skill rc-tdd-rodolfochicone
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: rc-tdd
Source: https://github.com/rodolfochicone/rc-project/tree/main/skills/promoted/rc-tdd
Command: npx skills add https://github.com/rodolfochicone/rc-project --skill rc-tdd-rodolfochicone

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Writing tests after the fact or testing implementation details produces brittle suites that break on refactors and verify nothing. This Skill enforces a disciplined red-green TDD loop so tests specify behavior through public interfaces and survive refactoring. ## Core Features & Use Cases - Red-Green Loop Discipline: Write the failing test first, watch it fail, then write only enough code to pass, one vertical slice per cycle. - Seam-Based Test Placement: Agree on testable seams (public interfaces) with the user before writing any test, so effort lands on critical paths. - Anti-Pattern Detection: Identifies implementation-coupled, tautological, horizontally sliced, and mock-testing tests, with a references/mocking.md guide covering mock completeness and complexity gates. - Use Case: When adding a checkout feature, confirm the public interface seams with the user, write one failing behavior test, implement the minimal code to pass, and repeat slice by slice. ## Quick Start Use the rc-tdd skill to build this feature test-first, starting by agreeing which seams we should test.

Frequently Asked Questions about rc-tdd

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

FAQPage Schema
How do I practice test-driven development effectively?▼

Follow the red-green loop: write a failing test that specifies behavior through a public interface, watch it fail, then write only enough code to pass. Work one vertical slice at a time and agree on testable seams before writing any test.

What is a seam in software testing?▼

A seam is a place where you can alter behavior without editing in that place, typically a public interface where behavior is observable. Tests should only be written at pre-agreed seams so testing effort lands on critical paths and complex logic.

Why do my tests break every time I refactor code?▼

Tests break on refactors when they are coupled to implementation details, such as mocking internal collaborators or testing private methods. Tests should verify behavior through public interfaces so they survive internal restructuring.

When should I use an integration test instead of mocks?▼

Switch to an integration test when mock setup exceeds the test length, you are re-implementing dependency logic in stubs, or you have not read the real dependency's contract. An integration test with real components is often simpler and verifies actual behavior.

Is high code coverage a sign of a good test suite?▼

Coverage is a floor, not a goal: it shows what was executed, never what was verified. A suite at 95% coverage built from tautological assertions verifies nothing, so check that covered branches have meaningful assertions first.