tdd-workflow

Use this skill when writing new features, fixing bugs, or refactoring code. Enforces test-driven development with 80%+ coverage including unit, integration, and E2E tests.

Quality

66%

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 ./.agents/skills/tdd-workflow/SKILL.md

Quality

Content

57%Weight 40%Scale 1-5

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

A thorough, code-rich TDD skill with a clear stepped workflow and useful runner/matrix guidance; its main weaknesses are verbosity in best-practice/mistake sections that restate known concepts, a missing validate-fix-retry feedback loop in the workflow, and no progressive disclosure of the large mock/pattern reference material into separate files.

Suggestions

Move the Supabase/Redis/OpenAI mock recipes, full E2E specs, and coverage-threshold config into reference files (e.g. references/mocking.md, references/e2e-patterns.md) and link to them from SKILL.md.

Add an explicit feedback loop after Step 3 and Step 5: on failure, read the error, fix the smallest cause, re-run `<test>`, and only proceed once GREEN — then run `<coverage>` as the final gate.

Cut the 'Best Practices', 'Common Testing Mistakes', and 'Success Metrics' sections to a few non-obvious items, removing guidance Claude already knows (one-assert-per-test, arrange-act-assert, test edge cases).

Dimension	Reasoning	Score
Conciseness	The body is largely useful and code-forward, but it pads sections Claude already knows (a 10-item 'Best Practices' list, 'Common Testing Mistakes', generic 'Success Metrics', boilerplate one-assert-per-test advice) that restate familiar testing concepts rather than adding net-new guidance.	3 / 5
Actionability	It provides mostly executable, copy-paste-ready patterns for unit/integration/E2E/Bun tests plus a concrete runner-detection matrix and mock snippets; minor gaps include placeholder test bodies ('// Test implementation') and the unresolved `<coverage>`/`<test>` tokens.	4 / 5
Workflow Clarity	The 7-step TDD sequence is clearly laid out with an explicit RED gate in Step 3 ('Tests should fail') and coverage verification in Step 7, but there is no validate→fix→retry feedback loop after a failing run and no explicit checkpoint before declaring GREEN, which the feedback-loops note expects for batch/test operations.	3 / 5
Progressive Disclosure	Structure is reasonable with sectioned headers, but the entire skill is a single ~467-line SKILL.md with no bundle files; large reference-style blocks (mock recipes, full E2E specs, coverage config) that would suit separate reference files are inlined, and there are no one-level-deep reference links to offload detail.	3 / 5
	Total	13 / 20 Passed

Description

75%Weight 40%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.

A well-constructed description that clearly states both the trigger conditions and the enforced policy (80%+ coverage across test types), using appropriate third-person voice. It is slightly broad in its action list and could add synonyms like 'TDD' or 'write tests' as natural trigger terms.

Suggestions

Add natural trigger synonyms users actually say, e.g. 'Use when writing tests, doing TDD, or raising coverage to 80%+.'

Tighten the 'when' list with one or two more specific triggers (e.g. 'adding API endpoints', 'before merging a PR') to reduce overlap with generic coding skills.

Lead with the most distinctive capability (enforce TDD red-green-refactor) before the generic feature/bug/refactor triggers.

Dimension	Reasoning	Score
Specificity	It names concrete actions ('writing new features, fixing bugs, or refactoring code') plus a measurable coverage policy ('80%+ coverage including unit, integration, and E2E tests'), but the action list is fairly broad rather than enumerating many distinct concrete operations.	4 / 5
Completeness	Both 'what' (enforces TDD with 80%+ coverage across unit/integration/E2E) and 'when' ('Use this skill when writing new features, fixing bugs, or refactoring code') are explicit; the 'when' list is solid but could name a few more specific triggering situations.	4 / 5
Trigger Term Quality	Natural phrases a user would say ('writing new features', 'fixing bugs', 'refactoring code') are present with good coverage, though it lacks synonyms/variants like 'TDD', 'write tests', or 'coverage' as user-facing trigger words.	4 / 5
Distinctiveness Conflict Risk	The TDD-with-coverage niche is fairly distinct and the triggers (features/bugs/refactor) are specific to development, but the broad 'writing new features' framing could lightly overlap with general coding skills.	4 / 5
	Total	16 / 20 Passed

Validation

93%

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 — 15 / 16 Passed

Validation for skill structure

Criteria	Description	Result
referenced_paths_exist	Referenced path issues: 1 missing	Warning

	Total	15 / 16 Passed

Repository: affaan-m/ECC
Path: .agents/skills/tdd-workflow/SKILL.md
Commit: d8409a4

Reviewed: 1 day 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.