common-tdd
Implements a strict Red-Green-Refactor loop to ensure zero production code is written without a prior failing test. Use when: creating new features, fixing bugs, or expanding test coverage. (triggers: **/*.test.ts, **/*.spec.ts, **/*_test.go, **/*Test.java, **/*_test.dart, **/*_spec.rb, tdd, unit test, write test, red green refactor, failing test, test coverage)
90
87%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
89%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 excels in completeness and trigger term coverage, with explicit 'Use when' guidance and a rich set of file patterns and natural language triggers spanning multiple languages. Its main weakness is that the capability description could be more granular—listing specific actions within the TDD loop rather than just naming the methodology. Overall, it would perform well in skill selection among a large pool of skills.
Suggestions
Expand the capability description to list specific concrete actions, e.g., 'Writes failing tests first, implements minimal production code to pass, then refactors for clarity and design' instead of just naming the loop.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | It names the domain (TDD/Red-Green-Refactor) and describes the core methodology ('zero production code without a prior failing test'), but doesn't list multiple concrete actions beyond the high-level loop. It could be more specific about what steps it performs (e.g., 'writes failing tests, implements minimal code to pass, refactors for clarity'). | 2 / 3 |
Completeness | Clearly answers both 'what' (implements strict Red-Green-Refactor loop ensuring no production code without a failing test) and 'when' (creating new features, fixing bugs, expanding test coverage) with explicit 'Use when:' clause and trigger terms. | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural trigger terms including file patterns across multiple languages (*.test.ts, *.spec.ts, *_test.go, *Test.java, etc.) and natural language terms users would say ('tdd', 'unit test', 'write test', 'red green refactor', 'failing test', 'test coverage'). | 3 / 3 |
Distinctiveness Conflict Risk | The TDD/Red-Green-Refactor methodology is a clear niche distinct from general testing or coding skills. The specific mention of the strict loop discipline and the comprehensive file pattern triggers make it unlikely to conflict with generic code generation or testing utility skills. | 3 / 3 |
Total | 11 / 12 Passed |
Implementation
85%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 that is concise, clearly sequenced, and appropriately uses progressive disclosure to reference files. Its main weakness is the lack of inline executable code examples — the AAA structure is described but the actual code is deferred to a reference file, which slightly reduces immediate actionability. The coverage thresholds, mock guidelines, and verification checklist add strong practical value.
Suggestions
Include at least one small inline code example demonstrating the AAA structure in a specific language rather than deferring entirely to references/aaa_example.md — this would make the skill immediately actionable without requiring file lookups.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The content is lean and efficient. It avoids explaining what TDD is conceptually and jumps straight into actionable rules. Every section earns its place with no padding or unnecessary context that Claude would already know. | 3 / 3 |
Actionability | The skill provides clear rules and structure (AAA, RGR loop, mock guidelines, coverage thresholds) but lacks executable code examples inline — the AAA code example is deferred to a reference file. The checklist and principles are concrete but not copy-paste ready. | 2 / 3 |
Workflow Clarity | The RGR loop is clearly sequenced with explicit verification at each step (verify failure, verify pass, stay green). The verification checklist provides a feedback loop, and the 'delete and restart' instruction for violations is an explicit error recovery mechanism. | 3 / 3 |
Progressive Disclosure | The skill provides a concise overview with well-signaled one-level-deep references to AAA examples, test runners, TDD patterns, and anti-patterns. Content is appropriately split between the main file and reference documents. | 3 / 3 |
Total | 11 / 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
- HoangNguyen0403/agent-skills-standard
- Commit
19a1140
- 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.