Guides the red-green-refactor TDD workflow: write a failing test first, implement the minimum code to make it pass, then refactor while keeping tests green. Use when a user asks to practice TDD, write tests first, follow red-green-refactor, do test-driven development, write failing tests before code, or phrases like 'make the test pass', 'test coverage', or 'unit tests before implementation'.
90
88%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
100%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This is a strong skill description that clearly articulates the TDD workflow, provides specific concrete actions, and includes an explicit 'Use when...' clause with excellent trigger term coverage. It uses proper third-person voice and is concise without being vague. The only minor concern is potential overlap with general testing skills on terms like 'test coverage' and 'unit tests', but the TDD-specific framing mitigates this well.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: 'write a failing test first', 'implement the minimum code to make it pass', 'refactor while keeping tests green'. These clearly describe the red-green-refactor workflow steps. | 3 / 3 |
Completeness | Clearly answers both 'what' (guides the red-green-refactor TDD workflow with specific steps) and 'when' (explicit 'Use when...' clause with multiple trigger phrases and scenarios). | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural trigger terms: 'TDD', 'write tests first', 'red-green-refactor', 'test-driven development', 'failing tests before code', 'make the test pass', 'test coverage', 'unit tests before implementation'. These are terms users would naturally use. | 3 / 3 |
Distinctiveness Conflict Risk | TDD/red-green-refactor is a clearly distinct methodology niche. While 'test coverage' and 'unit tests' could overlap with general testing skills, the combination with TDD-specific terms like 'red-green-refactor' and 'failing tests before code' makes it highly distinctive. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
77%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a solid, actionable TDD skill with excellent executable examples and clear workflow sequencing. Its main weakness is moderate verbosity — some sections explain concepts Claude already understands (common mistakes, decision points about when not to test), and the referenced integration skills don't exist in the bundle. The core RED-GREEN-REFACTOR cycle is taught effectively through concrete, runnable code.
Suggestions
Trim the 'Common Mistakes to Avoid' and 'Decision Points' sections — Claude already understands these TDD principles; keep only non-obvious guidance.
Either provide the referenced integration skills (test-patterns, anti-patterns, debugging/root-cause-analysis) as bundle files or remove the references to avoid dead links.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is mostly efficient with good executable examples, but includes some unnecessary guidance that Claude already knows (e.g., 'Understand the requirement — what specific behavior must exist?', 'Don't write a test when: Non-functional changes (formatting, comments)', common mistakes like 'Writing tests after code — defeats the design benefit of TDD'). The 'Common Mistakes to Avoid' and 'Decision Points' sections add moderate value but could be tighter. | 2 / 3 |
Actionability | Excellent executable examples throughout — the Jest code is copy-paste ready, shows the complete RED-GREEN-REFACTOR cycle with real code, and the end-to-end example demonstrates adding a new behavior with concrete, runnable code at each phase. | 3 / 3 |
Workflow Clarity | The workflow is clearly sequenced with explicit phases (RED → GREEN → REFACTOR), validation checkpoints ('Run the test — it MUST fail', 'Run tests after every change'), a verification checklist, and a feedback loop implicit in the cycle structure. The end-to-end example reinforces the sequence concretely. | 3 / 3 |
Progressive Disclosure | The content is well-structured with clear sections and headers, but it's somewhat long for a single file with no bundle support. The 'Integration with Other Skills' section references other skills (test-patterns, anti-patterns, debugging/root-cause-analysis) but these aren't provided in the bundle, and the inline content could benefit from splitting the end-to-end example or decision points into separate reference files. | 2 / 3 |
Total | 10 / 12 Passed |
Validation
90%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 10 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 10 / 11 Passed | |
a9e5c83
Table of Contents
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.