tlc-spec-driven
Project and feature planning with 4 adaptive phases - Specify, Design, Tasks, Execute. Auto-sizes depth by complexity. Creates atomic tasks with verification criteria, atomic git commits, requirement traceability, and persistent memory across sessions. Stack-agnostic. Use when (1) Starting new projects (initialize vision, goals, roadmap), (2) Working with existing codebases (map stack, architecture, conventions), (3) Planning features (requirements, design, task breakdown), (4) Implementing with verification and atomic commits, (5) Quick ad-hoc tasks (bug fixes, config changes), (6) Tracking decisions/blockers/deferred ideas across sessions, (7) Pausing/resuming work. Triggers on "initialize project", "map codebase", "specify feature", "discuss feature", "design", "tasks", "implement", "validate", "verify work", "UAT", "quick fix", "quick task", "pause work", "resume work". Do NOT use for architecture decomposition analysis (use architecture skills) or technical design docs (use create-technical-design-doc).
88
85%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Advisory
Suggest reviewing before use
Quality
Discovery
100%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This is an excellent skill description that thoroughly covers what the skill does, when to use it, and when NOT to use it. It provides rich trigger terms that match natural user language, lists concrete capabilities, and explicitly delineates boundaries with related skills. The only minor concern is that the description is quite long, but the density of useful information justifies the length.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions: adaptive 4-phase planning (Specify, Design, Tasks, Execute), atomic task creation with verification criteria, atomic git commits, requirement traceability, persistent memory, codebase mapping, and more. Very detailed and concrete. | 3 / 3 |
Completeness | Clearly answers both 'what' (project/feature planning with 4 adaptive phases, atomic commits, verification criteria, persistent memory) and 'when' (explicit 'Use when' clause with 7 numbered scenarios plus explicit trigger terms and a 'Do NOT use' exclusion clause). | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural trigger terms users would say: 'initialize project', 'map codebase', 'specify feature', 'design', 'tasks', 'implement', 'quick fix', 'pause work', 'resume work', 'verify work', 'UAT'. These are natural phrases a user would actually type. | 3 / 3 |
Distinctiveness Conflict Risk | Clearly carves out its niche with the specific 4-phase methodology and explicit exclusions ('Do NOT use for architecture decomposition analysis or technical design docs'). The trigger terms are distinctive and the boundary with related skills is explicitly defined. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
70%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a well-structured orchestration skill with excellent workflow clarity and progressive disclosure. Its main weakness is that actionability lives almost entirely in referenced files rather than the main body, and some sections (output behavior, skill integrations) add verbosity without proportional value. The auto-sizing table and safety valve are standout design choices.
Suggestions
Include at least one concrete, executable example inline (e.g., a sample spec.md or tasks.md snippet) so the main skill body has actionable content without requiring reference file lookups.
Trim the 'Output Behavior' section—guidance about suggesting cheaper models is meta-operational noise that doesn't help with the core planning/execution workflow.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is fairly well-organized and avoids explaining basic concepts, but it's quite lengthy (~300+ lines) with some sections that could be tightened. The sub-agent delegation table, context loading strategy, and skill integrations sections add significant bulk. The output behavior section about model guidance is unnecessary filler. | 2 / 3 |
Actionability | The skill provides clear structural guidance (file paths, tables, trigger patterns) but almost all actual implementation details are deferred to reference files. There are no executable code examples or concrete command-line invocations in the main skill body itself—everything actionable requires following a reference link. | 2 / 3 |
Workflow Clarity | The workflow is exceptionally clear with explicit sequencing (Specify → Design → Tasks → Execute), auto-sizing rules, a safety valve for when phases are wrongly skipped, and validation checkpoints throughout. The knowledge verification chain has strict ordering with error recovery (flag as uncertain). The sub-agent delegation includes clear return contracts. | 3 / 3 |
Progressive Disclosure | Excellent progressive disclosure with a clear overview in the main file and well-signaled one-level-deep references to specific reference files (implement.md, validate.md, discuss.md, etc.). The commands table serves as a navigation hub. Context loading strategy explicitly manages what to load and when. | 3 / 3 |
Total | 10 / 12 Passed |
Validation
100%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
- tech-leads-club/agent-skills
- Commit
906a57d
- 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.