Catalog
Yeachan-Heo/tdd

Test-first at pre-agreed seams — one test, one implementation, tracer-bullet red/green; independent expected values; substitutions only at the seam's boundary class; launch Phase 4 reference.

v1.0LATEST
NewUpdated Oct 2, 2026

TDD

Red-green in small steps, at seams that were agreed in advance. In a launch run the seam list is C2's approved output; outside launch, agree the seams with the user before the first test exists — a seam nobody approved gets no tests.

The loop

One test → one implementation → repeat:

  1. Write the next test at a seam. Run it. Watch it fail for the reason you expect — a test that cannot fail is not a test.
  2. Implement the smallest change that turns it green.
  3. Repeat. Each test is a tracer bullet: a narrow but complete path through the behavior, not a layer finished in isolation.

Rules

  • Expected values come from an independent source of truth — a spec line, a worked example, a documented output. Never from the implementation under test: a test that asserts what the code happens to do is a mirror, not a check.
  • Substitute at the seam's declared boundary class only — in-process, locally substitutable, owned-remote port, or true-external, the class C2 records for each seam. No substitutes inside the boundary the test is exercising.
  • Refactoring is not part of the loop. It belongs to the review stage; the repair worker owns it. Do not refactor mid-red-green.
  • A bug fix starts with the failing test that reproduces it — reproduction before theory, the debugger's rule.

When no seam fits

If the behavior cannot be tested at any approved seam, stop and say so: report the missing seam as a finding (it feeds architecture-survey and refit) rather than inventing a seam or testing through internals.

Output

  • The seam list used, with boundary classes
  • Red/green evidence — the failing run and the passing run
  • Any seam-absence findings
Files1
1 files · 1.0 KB

Select a file to preview

Overall Score

81/100

Grade

B

Good

Grades are signals, not a certification. Always review a skill yourself before use.

Safety

92

Quality

78

Clarity

88

Completeness

72

Summary

This skill teaches test-driven development (TDD) using a seam-based approach where tests are written at pre-agreed architectural boundaries. The skill enforces a strict red-green loop with tracer-bullet testing, independent expected values, and controlled substitutions, while explicitly forbidding mid-loop refactoring and internal testing. It is a methodology guide rather than an executable tool.

Detected Capabilities

test writingcode implementationarchitectural seam identificationtest failure analysisrefactoring coordination

Trigger Keywords

Phrases that agents use to match this skill to user intent.

test-driven developmentseam-based testingred-green cyclestracer bullet implementationarchitectural testing boundariestdd disciplineindependent test values

Use Cases

  • Implement features using strict TDD red-green cycles within architectural boundaries
  • Write independent unit tests with externally-sourced expected values
  • Debug failures by writing reproducer tests before theorizing
  • Identify missing architectural seams that block testability
  • Review code after test-implementation pairs are complete
  • Coordinate test-seam placement with C2 (requirement/design authority) in launch runs

Quality Notes

  • Strong pedagogical clarity: the skill uses a repeating cycle structure (loop, rules, output) that is easy to follow
  • Effective boundary enforcement: explicit prohibition on mid-loop refactoring and internal testing prevents scope creep and common TDD pitfalls
  • Well-grounded in seam-based architecture: references C2 (architecture authority) and approved seam lists, providing clear coordination boundaries
  • Practical failure-first rule: requires tests to fail for expected reasons, preventing mirror tests that confirm implementation rather than spec
  • Clear stopping condition: instructs agent to report missing seams rather than inventing workarounds, feeding architectural discovery
  • Context dependency: relies on external coordination (user approval of seams, C2 authority) that must be established before execution
  • Limited prescriptive tooling: does not specify test frameworks, languages, or assertion libraries—leaves implementation to user
  • Refactoring governance is firm but may conflict with some TDD schools that refactor within the loop; this is a deliberate stance documented in 'Rules'
Model: claude-haiku-4-5-20251001Analyzed: Oct 2, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Use Yeachan-Heo/tdd in your dev environment

Command Palette

Search for a command to run...