write-tests
Systematically add test coverage for all local code changes using specialized review and development agents. Add tests for uncommitted changes (including untracked files), or if everything is commited, then will cover latest commit.
56
46%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/tdd/skills/write-tests/SKILL.mdQuality
Discovery
57%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 communicates a clear purpose—adding test coverage for local code changes—and has a well-defined scope that distinguishes it from other skills. However, it lacks an explicit 'Use when...' clause and could benefit from more natural trigger terms that users would actually say when requesting this functionality.
Suggestions
Add an explicit 'Use when...' clause, e.g., 'Use when the user asks to write tests, add test coverage, or wants tests for their recent changes or uncommitted code.'
Include more natural trigger terms users would say, such as 'write tests', 'unit tests', 'missing tests', 'test my code', 'cover my changes'.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description names the domain (test coverage) and some actions (add test coverage, review changes, cover latest commit), but doesn't list specific concrete actions like 'generate unit tests, integration tests, mock dependencies, update test suites'. | 2 / 3 |
Completeness | The 'what' is reasonably clear (add test coverage for local code changes), and there's an implicit 'when' (uncommitted changes or latest commit), but there's no explicit 'Use when...' clause with trigger guidance, which caps this at 2 per the rubric. | 2 / 3 |
Trigger Term Quality | Includes relevant terms like 'test coverage', 'uncommitted changes', 'untracked files', 'latest commit', but misses common user phrases like 'write tests', 'unit tests', 'missing tests', 'test my code', 'add tests for my changes'. | 2 / 3 |
Distinctiveness Conflict Risk | The description carves out a clear niche: adding test coverage specifically for local code changes (uncommitted or latest commit). This is distinct from general testing skills, code review skills, or CI/CD skills, and the scope is well-defined. | 3 / 3 |
Total | 9 / 12 Passed |
Implementation
35%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill provides a reasonable orchestration framework for test coverage of local changes, with good structural ideas like parallel agent launches and iterative verification. However, it suffers from significant verbosity with redundant content between workflow steps and agent templates, lacks concrete executable examples, and has weak validation gates in the workflow. The skill would benefit greatly from trimming redundancy and adding concrete examples.
Suggestions
Remove or significantly condense the agent instruction templates — they largely duplicate the workflow steps. Consider moving them to a separate TEMPLATES.md file and referencing it.
Add a concrete, end-to-end example showing the skill in action on a real scenario (e.g., a specific file change, the git diff output, and the resulting test cases).
Add explicit validation gates: 'STOP if baseline tests fail before proceeding to analysis' and define concrete exit criteria for the iteration loop (e.g., max 3 iterations).
Remove explanatory context that Claude already knows (e.g., 'After implementing new features or refactoring existing code, it's critical to ensure all business logic changes are covered by tests') to improve token efficiency.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is very verbose with significant redundancy. The agent instruction templates at the bottom largely repeat the workflow steps above. There's unnecessary context explanation ('After implementing new features or refactoring existing code, it's critical to ensure...'), and the success criteria section restates what's already covered. The templates could be much more compact. | 1 / 3 |
Actionability | The skill provides a structured workflow with specific git commands and clear agent delegation patterns, but relies heavily on placeholders ({FILE_PATH}, {TEST_COMMAND}, {GIT_DIFF_OUTPUT}) without concrete examples. There are no executable code snippets showing actual test creation or coverage analysis. The 'sadd skill' and 'TDD skill' references are vague with no fallback if unavailable. | 2 / 3 |
Workflow Clarity | The workflow has clear sequencing with numbered steps and parallel execution noted, plus an iteration loop (step 9). However, validation checkpoints are weak — there's no explicit 'stop if tests fail before proceeding' gate, and the feedback loop between steps 8-9 lacks concrete criteria for when to stop iterating. The branching between simple and complex flows is clear but the simple flow lacks the same rigor. | 2 / 3 |
Progressive Disclosure | The skill references external resources (sadd skill, TDD skill, README.md) but these are vaguely signaled ('if available'). The agent instruction templates are inline and lengthy, adding ~60 lines that could be in separate files. There are no bundle files to support progressive disclosure, and the monolithic structure makes the skill harder to scan. | 2 / 3 |
Total | 7 / 12 Passed |
Validation
90%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
- NeoLabHQ/context-engineering-kit
- Commit
dedca19
- 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.