red-green-refactor
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, lists concrete actions for each phase, and provides an extensive 'Use when' clause with natural trigger terms. It uses proper third-person voice and covers both common and specific phrasings a user might employ. The only minor concern is potential overlap with general testing skills on terms like 'test coverage', but the TDD-specific context makes it sufficiently distinct.
| 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 cycle 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 through the red-green-refactor cycle. Its main weakness is moderate verbosity — some explanations are unnecessary for Claude, and the end-to-end example partially duplicates the phase-by-phase walkthrough. The progressive disclosure could be improved by linking to separate files for extended examples.
Suggestions
Trim explanatory text that Claude already knows (e.g., 'defeats the design benefit of TDD', 'resist adding more logic') to improve conciseness
Add proper markdown links to referenced skills in the Integration section (e.g., [test-patterns](./test-patterns/SKILL.md))
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is mostly efficient but includes some unnecessary explanation that Claude already knows (e.g., 'Don't add anything extra', 'resist adding more logic', explaining what TDD is). The 'Common Mistakes to Avoid' section largely restates things Claude would already understand. The end-to-end example adds value but creates some redundancy with the cycle sections. | 2 / 3 |
Actionability | Provides fully executable JavaScript/Jest code examples throughout all three phases, with concrete input/output values. The end-to-end example shows a complete second iteration of the cycle with copy-paste ready code. Decision points give specific, actionable guidance on when to write tests. | 3 / 3 |
Workflow Clarity | The three-phase cycle is clearly sequenced with explicit validation at each step (run test → must fail, run test → must pass, run tests after every refactor change). The verification checklist provides a feedback loop, and the workflow steps section gives a clear numbered sequence. The 'verify the failure reason' step catches a common error mode. | 3 / 3 |
Progressive Disclosure | The content is well-structured with clear headers and sections, but it's somewhat long for a single file. The 'Integration with Other Skills' section references other skills but doesn't use proper links. The end-to-end example could potentially be in a separate file to keep the main skill leaner. | 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 | |
- Repository
- rohitg00/skillkit
- Commit
dfa8d12
- Reviewed
Table of Contents
Is this your skill?
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.