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 other 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 phrases 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 explicit boundary-setting with other skills significantly reduces conflict risk. | 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 that excels at workflow clarity and progressive disclosure, serving as an effective routing document for a complex multi-phase development process. Its main weaknesses are moderate verbosity (some sections like sub-agent delegation and skill integrations could be more concise) and limited direct actionability since nearly all concrete instructions are deferred to reference files. The auto-sizing principle and safety valves are strong design choices.
Suggestions
Trim the sub-agent delegation section—the detailed table and return format could be moved to a reference file, keeping only the core delegation rules inline.
Remove or drastically shorten the 'Output Behavior' section about model guidance tips, as it's tangential to the skill's core purpose and adds unnecessary tokens.
| 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 token weight. The output behavior section about model guidance is unnecessary filler. | 2 / 3 |
Actionability | The skill provides clear structural guidance (file paths, tables, workflows) but almost all concrete implementation details are deferred to reference files. There are no executable code examples or copy-paste ready commands in the main skill body itself—it's primarily a routing document pointing to other files for actual instructions. | 2 / 3 |
Workflow Clarity | The multi-step workflows are clearly sequenced with explicit phases, auto-sizing rules, and a safety valve for when Tasks phase is wrongly skipped. The Knowledge Verification Chain has strict ordering with clear escalation. Validation checkpoints are embedded (verify per task, gate checks, SPEC_DEVIATION markers). The feedback loop of 'if >5 steps discovered, STOP and formalize' is a strong error recovery mechanism. | 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 (e.g., [implement.md], [validate.md], [discuss.md]). The Commands section serves as a clean navigation index. Content is appropriately split between the overview and detailed reference files. | 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.
81e7e0d
Table of Contents
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.