tdd-mastery

Test-driven development workflow with Red-Green-Refactor cycle across languages

Quality

65%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./skills/tdd-mastery/SKILL.md

Quality

Content

80%

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

The content is lean, assumption-respecting, and highly actionable, with executable examples and concrete commands across three languages. Its main weaknesses are implicit (rather than explicit) validation checkpoints in the core cycle and an all-inline structure that, for a skill this size, would benefit from offloading per-language details into reference files.

Suggestions

Make the cycle's validation explicit, e.g. add 'Run the suite; only refactor while tests stay green' as a checkpoint step in the Red-Green-Refactor list.

Move the Jest/Vitest, pytest, and Go pattern blocks into per-language reference files (e.g. references/jest.md) and link them from SKILL.md to improve progressive disclosure.

Consider an explicit error-recovery note for the common failure case (test stays red) to strengthen the workflow feedback loop.

Dimension	Reasoning	Score
Conciseness	The body is dense with executable patterns and assumes Claude's competence throughout, with no padding explaining what TDD, mocking, or coverage are; each section (cycle, structure, per-language patterns, levels, coverage, mocking, anti-patterns) earns its place for an 'across languages' skill.	3 / 3
Actionability	It provides complete, executable code for Jest/Vitest, pytest, and Go, plus copy-paste-ready coverage commands such as 'vitest run --coverage --coverage.thresholds.lines=80' and 'pytest --cov=src --cov-fail-under=80 --cov-branch', matching the score-3 anchor of fully executable, specific examples.	3 / 3
Workflow Clarity	The Red-Green-Refactor cycle is a clearly numbered 3-step sequence with an implicit feedback loop ('keeping tests green'), but there are no explicit validation checkpoints (e.g. 'run the suite; if red, fix before refactoring'), so the sequence is present while checkpoints remain implicit.	2 / 3
Progressive Disclosure	The body is well-organized with clear section headers, but at ~140 lines it is entirely inline with no bundle files; the per-language pattern sections and coverage reference material could be split into one-level-deep reference files, fitting the score-2 anchor where content that should be separate is inline.	2 / 3
	Total	10 / 12 Passed

Description

50%

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 correctly identifies the TDD niche and its Red-Green-Refactor cycle, but lacks an explicit 'Use when' trigger clause and only partially covers natural user keywords, capping several dimensions at 2. Adding a concrete trigger phrase and common synonyms (TDD, write tests first) would raise specificity, completeness, and trigger-term quality.

Suggestions

Add an explicit 'Use when...' clause, e.g. 'Use when the user wants to practice TDD, write tests first, or apply the Red-Green-Refactor cycle.'

Include common natural keywords users say: 'TDD', 'write tests first', 'unit testing workflow', 'test-first development'.

List one or two concrete actions (e.g. 'write failing tests, make them pass, refactor') to push specificity toward the score-3 anchor.

Dimension	Reasoning	Score
Specificity	The phrase 'Test-driven development workflow with Red-Green-Refactor cycle across languages' names the domain and the canonical cycle, but does not enumerate multiple concrete actions (e.g. write failing tests, refactor, run suites); it stops at naming the workflow rather than listing specific actions like the score-3 anchor.	2 / 3
Completeness	It states what the skill does (TDD workflow with the Red-Green-Refactor cycle), but provides no 'Use when...' clause or equivalent explicit trigger guidance; per the guidelines a missing trigger clause caps completeness at 2.	2 / 3
Trigger Term Quality	'Test-driven development' and 'Red-Green-Refactor' are recognizable domain terms, but it omits common user phrasings like 'TDD', 'write tests first', 'unit testing', or 'test workflow', so coverage of natural terms is partial.	2 / 3
Distinctiveness Conflict Risk	'Test-driven development workflow' is a recognizable niche, but 'across languages' broadens it and it could overlap with general testing or per-language testing skills, especially without explicit triggers to distinguish it.	2 / 3
	Total	8 / 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 — 16 / 16 Passed

Validation for skill structure

No warnings or errors.

Repository: rohitg00/awesome-claude-code-toolkit
Path: skills/tdd-mastery/SKILL.md
Commit: ebdf1d5

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.