test-driven-development

Drives development with tests. Use when implementing any logic, fixing any bug, or changing any behavior. Use when you need to prove that code works, when a bug report arrives, or when you're about to modify existing functionality.

Quality

63%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Advisory

Suggest reviewing before use

Optimize this skill with Tessl

npx tessl skill review --optimize ./skills/test-driven-development/SKILL.md

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 comprehensive and highly actionable TDD skill with excellent workflow clarity and concrete, executable examples. Its main weakness is verbosity — it includes philosophical justifications (Common Rationalizations, Beyoncé Rule), explanations of well-known concepts (test pyramid, DAMP vs DRY), and a lengthy Browser Testing section that could be offloaded to referenced files. The content would be stronger at roughly 60% of its current length with better progressive disclosure.

Suggestions

Move the 'Common Rationalizations' table, 'Browser Testing with DevTools' section, and 'Test Anti-Patterns' table into separate referenced files to reduce the main SKILL.md to its core TDD workflow and patterns.

Cut or drastically shorten the Test Pyramid section and test sizing table — Claude already understands these concepts; a one-line preference statement ('Favor small, fast unit tests; use integration/E2E tests sparingly for boundaries and critical paths') suffices.

Ensure referenced files (`browser-testing-with-devtools`, `references/testing-patterns.md`) actually exist in the bundle to support the progressive disclosure structure.

Dimension	Reasoning	Score
Conciseness	The skill is well-written but verbose for its audience. Sections like 'Common Rationalizations', the test pyramid explanation, the Beyoncé Rule, and general TDD philosophy are concepts Claude already knows well. The ASCII diagrams are nice but add tokens. The core actionable content could be delivered in roughly half the space.	2 / 3
Actionability	Excellent actionable content throughout — executable TypeScript examples for every pattern (RED/GREEN/REFACTOR, Prove-It, Arrange-Act-Assert), concrete anti-pattern tables with fixes, specific verification checklists, and copy-paste-ready test examples. The guidance is specific and immediately usable.	3 / 3
Workflow Clarity	The TDD cycle is clearly sequenced with explicit validation at each step (test fails → write code → test passes → refactor → tests still pass). The Prove-It Pattern for bug fixes includes a clear flow with validation checkpoints. The verification checklist at the end provides a final validation gate. The DevTools debugging workflow also follows a clear sequence with verification.	3 / 3
Progressive Disclosure	References to `browser-testing-with-devtools` and `references/testing-patterns.md` are mentioned but no bundle files are provided, making it impossible to verify they exist. The SKILL.md itself is quite long (~300 lines) and could benefit from moving the Browser Testing section, anti-patterns table, and Common Rationalizations into separate reference files, keeping the main file focused on the core TDD workflow.	2 / 3
	Total	10 / 12 Passed

Description

49%

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

The description has strong completeness with explicit 'Use when' clauses, but suffers from being overly broad and vague. The triggers are so generic ('any logic', 'any bug', 'any behavior') that this skill would conflict with almost every other development skill. The 'what' portion lacks concrete actions — it doesn't specify what kind of tests are written or what testing methodology is applied.

Suggestions

Add specific concrete actions like 'Writes unit tests, generates test fixtures, creates regression tests, and runs test suites using TDD methodology'

Narrow the trigger conditions to avoid conflicting with general coding skills — e.g., 'Use when the user explicitly asks for tests, TDD, test coverage, or test-driven development' rather than 'any logic' or 'any bug'

Include natural trigger terms users would say such as 'unit test', 'TDD', 'test-driven', 'test coverage', 'spec', 'assertion', or specific framework names

Dimension	Reasoning	Score
Specificity	The description uses vague language like 'drives development with tests' and 'implementing any logic' without listing concrete actions. It doesn't specify what kind of tests, what frameworks, or what specific operations (e.g., 'write unit tests', 'generate test fixtures', 'run test suites').	1 / 3
Completeness	The description answers both 'what' (drives development with tests) and 'when' with explicit triggers ('Use when implementing any logic, fixing any bug, or changing any behavior. Use when you need to prove that code works, when a bug report arrives, or when you're about to modify existing functionality').	3 / 3
Trigger Term Quality	Includes some relevant terms like 'tests', 'bug', 'fixing', and 'behavior' that users might naturally say. However, it misses common variations like 'unit test', 'TDD', 'test-driven', 'test coverage', 'assertion', 'spec', or specific testing framework names.	2 / 3
Distinctiveness Conflict Risk	The triggers are extremely broad — 'implementing any logic', 'fixing any bug', 'changing any behavior' would match virtually every coding task. This would conflict with nearly any development-related skill and trigger far too often.	1 / 3
	Total	7 / 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: addyosmani/agent-skills
Commit: 5e262b2

Reviewed: 2 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.