tdd
Test-driven development with red-green-refactor loop. Use when user wants to build features or fix bugs using TDD, mentions "red-green-refactor", wants integration tests, or asks for test-first development.
62
72%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./.agents/skills/tdd/SKILL.mdQuality
Discovery
82%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 solid description with a clear 'Use when' clause and good trigger term coverage. Its main weaknesses are the lack of specific concrete actions (what exactly does the skill do beyond naming the methodology?) and some generic trigger phrases like 'build features or fix bugs' that could cause overlap with other coding skills.
Suggestions
Add specific concrete actions like 'Writes failing tests first, implements minimal code to pass, then refactors for clean design' to improve specificity.
Narrow the generic triggers 'build features or fix bugs' by qualifying them, e.g., 'build features using a test-first approach' to reduce conflict risk with general coding skills.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (TDD) and mentions the red-green-refactor loop, but doesn't list specific concrete actions like 'write failing tests', 'implement minimal code', 'refactor for clean design'. The actions are implied by the methodology name rather than explicitly enumerated. | 2 / 3 |
Completeness | Clearly answers both 'what' (test-driven development with red-green-refactor loop) and 'when' (explicit 'Use when' clause listing multiple trigger scenarios including TDD, red-green-refactor, integration tests, and test-first development). | 3 / 3 |
Trigger Term Quality | Includes strong natural trigger terms: 'TDD', 'red-green-refactor', 'integration tests', 'test-first development', 'build features', 'fix bugs'. These cover a good range of terms users would naturally say when wanting this workflow. | 3 / 3 |
Distinctiveness Conflict Risk | The TDD and red-green-refactor triggers are fairly distinctive, but 'build features or fix bugs' is very generic and could overlap with many coding skills. 'Integration tests' could also conflict with a general testing skill. | 2 / 3 |
Total | 10 / 12 Passed |
Implementation
62%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a well-structured TDD skill with excellent workflow clarity and a strong opinionated stance on vertical slicing vs horizontal slicing. Its main weaknesses are the lack of concrete, executable code examples (no actual test/implementation shown) and some verbosity in the philosophy and anti-pattern sections that explain concepts Claude already knows. The referenced supporting files would improve progressive disclosure if they existed.
Suggestions
Add a concrete, executable code example showing one full RED→GREEN→REFACTOR cycle (e.g., a simple function with a real test in a specific language/framework) to boost actionability.
Trim the philosophy section significantly—Claude understands testing concepts; focus on the project-specific opinions (behavior-over-implementation, integration-style) in 2-3 sentences rather than full paragraphs with examples of good vs bad.
Provide the referenced bundle files (tests.md, mocking.md, deep-modules.md, interface-design.md, refactoring.md) or remove the references to avoid broken links.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The philosophy section over-explains what good vs bad tests are—concepts Claude already understands well. The anti-pattern section is valuable but somewhat verbose in its explanation. The workflow and checklist sections are reasonably tight. | 2 / 3 |
Actionability | The workflow provides clear steps and checklists, but lacks concrete, executable code examples. The RED→GREEN diagrams are illustrative but abstract—no actual test code or implementation code is shown. A TDD skill would benefit greatly from a concrete example showing a real test→implementation cycle. | 2 / 3 |
Workflow Clarity | The workflow is clearly sequenced (Planning → Tracer Bullet → Incremental Loop → Refactor) with explicit validation checkpoints (checklists per cycle, 'run tests after each refactor step', 'never refactor while RED'). The feedback loop of RED→GREEN→REFACTOR is well-articulated with clear rules at each stage. | 3 / 3 |
Progressive Disclosure | References to supporting files (tests.md, mocking.md, deep-modules.md, interface-design.md, refactoring.md) are well-signaled and one level deep, which is good. However, no bundle files are provided, so these references are broken. The philosophy section is also quite long and could be split out, keeping SKILL.md as a leaner overview. | 2 / 3 |
Total | 9 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
- Repository
- coder/agent-tty
- Commit
a05d4e5
- 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.