tdd

Enforces strict test-driven development -- write a failing test first, implement minimal code to pass, then refactor. Use when implementing a feature, fixing a bug, adding behavior, refactoring, or any time production code will be written or changed. Also use when the user says "write tests", "add tests", "TDD", or "test first". DO NOT TRIGGER for throwaway prototypes, generated code, or config-only changes unless the user explicitly requests TDD.

Quality

88%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Passed

No known issues

Quality

Content

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 strong, highly actionable TDD skill with excellent workflow clarity and concrete examples. Its main weakness is verbosity: the philosophical justifications for TDD and the excuse-rebuttal tables consume significant tokens arguing a position rather than instructing behavior. The content would benefit from trimming persuasive sections and splitting reference material into bundle files.

Suggestions

Move the 'Why Order Matters' and 'Recognizing When You've Left TDD' sections (including the excuse tables) into a separate reference file like `tdd-rationale.md` to reduce the main skill's token footprint.

Provide the referenced `testing-anti-patterns.md` bundle file, or remove the reference if it doesn't exist.

Remove the dot graph definition—it's not renderable in most contexts Claude operates in and the RED→GREEN→REFACTOR cycle is already clearly explained in the text.

Dimension	Reasoning	Score
Conciseness	The skill is well-structured but includes significant verbosity in the 'Why Order Matters' section that argues for TDD philosophy—something Claude doesn't need to be convinced of. The 'Recognizing When You've Left TDD' section with its excuse table is also somewhat redundant given the hard gate rule. The core workflow sections are efficient, but the persuasive/motivational content adds ~30% unnecessary tokens.	2 / 3
Actionability	Excellent concrete examples throughout: executable TypeScript code for both good and bad patterns, specific bash commands for verification, a complete bug fix walkthrough with RED/GREEN/REFACTOR, and clear tables for troubleshooting. Every step has copy-paste ready code and commands.	3 / 3
Workflow Clarity	The RED → Verify RED → GREEN → Verify GREEN → REFACTOR → Repeat cycle is explicitly sequenced with validation checkpoints at each transition. Each verification step includes specific criteria for pass/fail and what to do on failure (feedback loops like 'Test passes? Fix test.' and 'Other tests fail? Fix now.'). The verification checklist at the end provides a final gate.	3 / 3
Progressive Disclosure	The skill references `testing-anti-patterns.md` at the end, which is good progressive disclosure, but no bundle file is provided for it. The main content is quite long (~300 lines) and the philosophical/motivational sections ('Why Order Matters', 'Recognizing When You've Left TDD') could be split into a separate reference file. The dot graph is a nice touch but adds bulk to the main file.	2 / 3
	Total	10 / 12 Passed

Description

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 an excellent skill description that clearly defines the TDD methodology it enforces, provides comprehensive trigger terms covering both explicit user requests and implicit scenarios, and includes thoughtful exclusion criteria. The description uses proper third-person voice and is concise yet thorough, making it easy for Claude to distinguish this skill from general coding or testing skills.

Dimension	Reasoning	Score
Specificity	Lists multiple concrete actions: 'write a failing test first, implement minimal code to pass, then refactor.' Also specifies concrete scenarios like implementing features, fixing bugs, adding behavior, and refactoring.	3 / 3
Completeness	Clearly answers both 'what' (enforces strict TDD with red-green-refactor cycle) and 'when' (explicit 'Use when...' clause with multiple trigger scenarios, plus a 'DO NOT TRIGGER' exclusion clause for additional clarity).	3 / 3
Trigger Term Quality	Excellent coverage of natural trigger terms users would say: 'write tests', 'add tests', 'TDD', 'test first', plus contextual triggers like 'implementing a feature', 'fixing a bug', 'refactoring'. Also includes negative triggers for when NOT to use it.	3 / 3
Distinctiveness Conflict Risk	Highly distinctive with a clear niche (TDD methodology enforcement). The explicit exclusion of throwaway prototypes, generated code, and config-only changes further reduces conflict risk with other coding or testing skills.	3 / 3
	Total	12 / 12 Passed

Validation

100%

Warnings & errors only

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: shousper/claude-kit
Commit: 08bc600

Reviewed: 14 days ago

Table of Contents

Discovery Implementation Validation

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.