This skill should be used when the user says "planning", "arness planning", "plan a feature", "start planning", "I want to build", "new feature", "plan something", "what should I build", "pick an issue", "plan a bug fix", "I have an idea", "spec and plan", "plan from scratch", "plan this", "feature planning", "bug planning", "plan this issue", "arn-planning", or wants to go from an idea, issue, or bug report through to a complete implementation plan ready for execution. Handles severity-aware scope routing across three ceremony tiers (swift, standard, thorough), routing between feature specs, bug specs, and quick implementations, and produces a reviewed plan ready for execution. Chains to arn-implementing at completion.
56
64%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Advisory
Suggest reviewing before use
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/arn-code/skills/arn-planning/SKILL.mdQuality
Discovery
82%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 excels at providing comprehensive trigger terms and clearly answering both what and when, making it strong on completeness and trigger quality. However, the actual capabilities described lean toward process jargon ('severity-aware scope routing', 'ceremony tiers') rather than concrete user-facing actions, and some trigger terms are broad enough to potentially conflict with implementation-focused skills.
Suggestions
Replace jargon like 'severity-aware scope routing' and 'ceremony tiers' with plain descriptions of what the skill actually produces (e.g., 'creates step-by-step implementation plans with file-level changes, generates feature specifications with acceptance criteria').
Narrow overly broad triggers like 'I want to build' and 'new feature' by clarifying these apply specifically to the planning phase, not the implementation phase, to reduce conflict risk with coding/implementation skills.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description mentions some concrete actions like 'severity-aware scope routing', 'routing between feature specs, bug specs, and quick implementations', and 'produces a reviewed plan ready for execution', but these are somewhat jargon-heavy and not fully concrete in terms of what specific actions are performed (e.g., what does a 'feature spec' entail?). | 2 / 3 |
Completeness | The description explicitly answers both 'what does this do' (routes between feature/bug specs across ceremony tiers, produces reviewed implementation plans) and 'when should Claude use it' (extensive trigger phrase list plus the general condition of going from idea/issue/bug to implementation plan). The 'Use when' equivalent is the opening clause. | 3 / 3 |
Trigger Term Quality | The description includes an extensive list of natural trigger phrases users would actually say, such as 'plan a feature', 'I want to build', 'new feature', 'I have an idea', 'plan a bug fix', 'pick an issue', and 'plan from scratch'. These cover a wide range of natural user language variations. | 3 / 3 |
Distinctiveness Conflict Risk | While the planning-specific triggers and the three-tier ceremony system help distinguish it, some trigger terms like 'I want to build', 'new feature', and 'I have an idea' are quite broad and could overlap with implementation or coding skills. The mention of chaining to 'arn-implementing' helps somewhat, but the generic planning terms could still cause conflicts. | 2 / 3 |
Total | 10 / 12 Passed |
Implementation
47%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a comprehensive orchestration skill with excellent workflow clarity and state management, but it suffers significantly from verbosity. The repeated preference-check pattern (appearing 3 times with nearly identical logic) and the inline progress bars bloat the content substantially. The skill would benefit greatly from extracting repeated patterns into shared references, which would also improve progressive disclosure.
Suggestions
Extract the repeated preference check pattern (two-tier lookup → branch on value → gate → 'remember this?' follow-up → write-back) into a shared reference file like `references/preference-gate-pattern.md` and reference it from each gate, reducing ~60% of the repetition.
Add a concrete YAML example showing the expected structure of `~/.arness/workflow-preferences.yaml` and `.arness/workflow.local.yaml` rather than describing the read/write operations procedurally each time.
Move the detailed G1 option presentation logic (greenfield backlog variants with conditional option counts) into a reference file, keeping only the routing summary inline.
Consider removing the repeated ASCII progress bars or replacing them with a single reference showing the full pipeline and just noting the current step name at each gate.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | This skill is extremely verbose at ~400+ lines. While it's an orchestration skill, there is massive repetition — the preference check pattern (two-tier lookup, write-back logic, 'remember this?' follow-up) is duplicated nearly identically across G2, G3, and G4. This could be factored into a shared reference. The progress bar ASCII art is repeated 10 times. Many decision trees could be expressed more compactly as tables or references. | 1 / 3 |
Actionability | The skill provides very specific routing logic, decision tables, and exact skill invocation syntax. However, it contains no executable code — all actions are described procedurally rather than with concrete commands or code snippets. The preference file read/write operations describe what to do but never show the actual YAML structure or file manipulation commands. | 2 / 3 |
Workflow Clarity | The workflow is exceptionally well-sequenced with numbered steps, explicit gates (G1-G5), clear decision tables for routing, state detection with resume points, progress indicators at each step, and error handling with recovery paths. Validation checkpoints exist at spec review and plan review stages with explicit feedback loops. | 3 / 3 |
Progressive Disclosure | The skill references external files appropriately (scope-router-criteria.md, preferences-schema.md, step-0-fast-path.md) and delegates to sub-skills. However, the massive inline content — particularly the repeated preference check patterns and the detailed G1/G2/G3/G4 gate logic — should be factored into reference files. The skill states it 'MUST NOT duplicate sub-skill logic' but then includes extensive inline decision trees that could live in references. | 2 / 3 |
Total | 8 / 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 | |
b9084b6
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.