tdd-workflows-tdd-green

Implement the minimal code needed to make failing tests pass in the TDD green phase.

Quality

43%

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-workflows-tdd-green/SKILL.md

Quality

Content

42%Scale 1-5

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

The skill content suffers from a mismatch between its stated purpose (implementing minimal code to pass failing tests in TDD green phase) and its actual content (showing refactoring progressions in Django and Express). The code examples are concrete but don't demonstrate the core skill, and the inlined refactoring patterns bloat the file while belonging either in a separate skill or the referenced playbook. The workflow steps are reasonable but lack validation detail.

Suggestions

Replace the Django/Express refactoring examples with a concrete example showing a failing test alongside the minimal implementation that makes it pass—this directly demonstrates the green phase skill.

Move the refactoring progression examples to `resources/implementation-playbook.md` or a separate refactoring skill, since they describe the refactor phase rather than the green phase.

Add a feedback loop to the workflow: what to do when the minimal change doesn't pass the test, or when it causes other tests to fail (e.g., 'If other tests break, revert and try a smaller change').

Include a concrete command for running tests (e.g., `pytest -x` or `npm test`) in the Instructions to make step 3 more actionable.

Dimension	Reasoning	Score
Conciseness	The content is noticeably verbose with extensive code examples showing refactoring progressions (Django and Express patterns) that are tangential to the core skill of making failing tests pass. The refactoring examples belong in a separate refactoring skill, and the Django/Express patterns explain concepts Claude already knows.	2 / 5
Actionability	The Instructions section provides a reasonable 4-step process, and the code examples are concrete and executable. However, the examples don't actually demonstrate the core skill—making a failing test pass—since no test code is shown alongside the implementations. The gap between 'review failing tests' and the provided code patterns is significant.	3 / 5
Workflow Clarity	The Instructions section lists a clear 4-step sequence (review tests, implement minimal change, run tests, record debt), but lacks explicit validation checkpoints. Step 3 mentions running tests but there's no feedback loop for what to do if tests still fail, and no concrete commands or verification steps are provided.	3 / 5
Progressive Disclosure	There's a reference to `resources/implementation-playbook.md` for detailed patterns, which is good progressive disclosure. However, the bulk of the code examples (Django and Express refactoring patterns) are inlined when they should be in that referenced file, and the referenced file doesn't exist in the bundle.	3 / 5
	Total	11 / 20 Passed

Description

45%Scale 1-5

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 identifies a specific TDD phase and a concrete action but lacks a 'Use when...' clause, which is critical for skill selection among many options. It also misses natural synonyms and variations that users might employ, and doesn't elaborate on the specific sub-actions involved in the green phase workflow.

Suggestions

Add an explicit 'Use when...' clause with trigger phrases such as 'when the user is in the TDD green phase', 'when tests are failing and need minimal implementation', or 'when doing red-green-refactor'.

Include natural synonyms and related terms like 'test-driven development', 'make tests green', 'red-green-refactor', 'fix failing tests', 'implement to pass tests'.

Expand the capability description with more specific actions, e.g., 'Reads test failure output, identifies the minimal production code changes needed, and implements just enough code to make all failing tests pass without over-engineering.'

Dimension	Reasoning	Score
Specificity	Names the domain (TDD green phase) and one concrete action (implement minimal code to make failing tests pass), but doesn't elaborate on what that entails—e.g., reading test output, modifying source files, running tests to verify.	3 / 5
Completeness	Provides a clear 'what' (implement minimal code to make failing tests pass) but has no explicit 'when' clause or trigger guidance. Per rubric guidelines, a missing 'Use when...' clause caps completeness at 3, and the lack of any implicit trigger guidance places this at 2.	2 / 5
Trigger Term Quality	Includes relevant terms like 'TDD', 'green phase', 'failing tests', and 'tests pass', but misses natural user phrases like 'make tests green', 'fix failing tests', 'red-green-refactor', or 'test-driven development'.	3 / 5
Distinctiveness Conflict Risk	The specific mention of 'TDD green phase' and 'minimal code' to pass failing tests carves out a fairly distinct niche, though it could overlap with general test-fixing or debugging skills.	4 / 5
	Total	12 / 20 Passed

Validation

90%

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 — 10 / 11 Passed

Validation for skill structure

Criteria	Description	Result
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	10 / 11 Passed

Repository: administrakt0r/AI-Agents-Safe-Coding-Skills
Path: skills/tdd-workflows-tdd-green/SKILL.md
Commit: fbdfd63

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.