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.

NewUpdated Oct 13, 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 proposing a seam, say in one line what it catches and what it lets through — a seam choice nobody can price is a guess, not a decision.

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 and each seam's catch/miss line
  • 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

82/100

Grade

B

Good

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

Safety

88

Quality

80

Clarity

85

Completeness

72

Summary

This skill teaches test-driven development (TDD) at pre-agreed architectural seams, using a red-green-red loop with independent expected values and substitutions only at declared boundary classes. It guides agents to write tracer-bullet tests that exercise complete behavioral paths, report missing seams as findings rather than invent them, and distinguish between test output (red/green evidence) and architectural constraints (approved seam list).

Detected Capabilities

test writing and executioncode implementationseam boundary analysisarchitecture documentation review

Trigger Keywords

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

test-driven developmentred green cycletracer bullet testsseam-based testingarchitecture-first testingtdd workflowintegration test seams

Use Cases

  • Implement features using red-green-red test cycles at approved architectural boundaries
  • Validate new behavior against independent sources of truth (specs, worked examples)
  • Debug production issues by writing failing tests that reproduce the bug first
  • Evaluate architectural seam choices before committing to test coverage
  • Report missing seams as architecture survey findings for redesign work

Quality Notes

  • Clear red-green loop structure with numbered steps makes the core workflow easy to follow
  • Strong emphasis on independent expected values prevents test-against-implementation anti-pattern
  • Seam-boundary discipline and explicit substitution rules prevent over-mocking
  • Practical guardrail: 'if no seam fits, stop and report' prevents test-path invention
  • Rules section covers common pitfalls (refactoring mid-loop, mirror tests, untested substitutes)
  • Bug-fix guidance ('reproduction before theory') connects TDD to debugging discipline
  • One-line seam description requirement ('what it catches, what it lets through') enforces architectural thinking
  • Output requirements clearly define done-state (seam list, red/green evidence, findings)
Model: claude-haiku-4-5-20251001Analyzed: Oct 13, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Version History

  1. v1.1

    Content updated

    ✦ AIRequires seams be justified by a one-line catch/miss statement; output now explicitly lists it per seam.

    2026-10-13

    LATEST
  2. v1.0

    2026-10-02

    View This VersionInitial version

Use Yeachan-Heo/tdd in your dev environment

Command Palette

Search for a command to run...