This skill should be used when the user says "implementing", "arness implementing", "start implementing", "execute the plan", "build it", "implement this", "run the tasks", "execute", "start building", "implement the feature", "implement the fix", "quick change", "swift", "swift mode", "quick implementation", "standard", "standard mode", "standard implementation", "start execution", "build the feature", "arn-implementing", or wants to execute an implementation plan, run a quick implementation, a standard-tier implementation, or manage the build-simplify-review cycle. Chains to arn-shipping at completion.
60
51%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/arn-code/skills/arn-implementing/SKILL.mdQuality
Discovery
54%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 description is heavily front-loaded with trigger terms but almost entirely neglects explaining what the skill actually does. It reads as a list of activation phrases rather than a meaningful description of capabilities. The lack of concrete actions (what code does it write? what kind of implementations? what is the build-simplify-review cycle?) makes it difficult for Claude to understand the skill's purpose beyond pattern-matching on keywords.
Suggestions
Add concrete capability descriptions: specify what the skill does (e.g., 'Executes multi-step implementation plans by writing code, creating files, running tests, and refactoring for simplicity').
Explain the 'build-simplify-review cycle' — this appears to be a core concept but is never defined, leaving Claude unable to understand the skill's workflow.
Reduce the exhaustive trigger term list and instead describe the skill's domain and purpose clearly; a well-described skill naturally matches relevant queries without needing 20+ explicit trigger phrases.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description lacks concrete actions. It mentions 'execute an implementation plan', 'run a quick implementation', 'manage the build-simplify-review cycle' but never specifies what the skill actually does — no concrete capabilities like 'writes code', 'creates files', 'refactors modules', etc. are listed. | 1 / 3 |
Completeness | The 'when' is extensively covered with explicit trigger phrases and a 'Use when' equivalent. However, the 'what' is extremely weak — it never clearly explains what the skill actually does beyond vague references to 'implementation' and 'build-simplify-review cycle'. The imbalance caps this at 2. | 2 / 3 |
Trigger Term Quality | The description is heavily loaded with trigger terms and natural phrases users would say: 'implementing', 'build it', 'execute the plan', 'quick change', 'swift mode', 'standard mode', 'implement the feature', 'implement the fix', etc. These cover many natural variations a user might use. | 3 / 3 |
Distinctiveness Conflict Risk | Terms like 'implementing', 'build it', 'execute', and 'start building' are very generic and could easily conflict with any coding or development skill. The 'arn-implementing' and 'arness implementing' prefixes add some distinctiveness, but the majority of triggers are broadly applicable. | 2 / 3 |
Total | 8 / 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 well-structured orchestration skill with excellent workflow clarity — the state detection table, gate progression, and preference system are thorough and unambiguous. However, it is significantly over-verbose: the preference lookup chain is duplicated, CHANGE_RECORD field specs are inlined rather than referenced, and many patterns repeat across gates. The skill would benefit greatly from extracting repeated patterns into shared references and compressing the gate descriptions into a more tabular format.
Suggestions
Extract the repeated two-tier preference lookup chain (used identically in G3 and G4) into a shared reference file and reference it once, reducing ~40 lines of duplication to a single pointer.
Move the CHANGE_RECORD.json field-by-field specification to a reference file (e.g., change-record-spec.md) — the current inline detail adds ~30 lines that Claude can look up on demand.
Compress the gate patterns into a more compact format — each gate follows the same structure (progress bar, preference check, ask, follow-up) which could be templated rather than fully expanded for each instance.
Consider a summary decision table at the top showing all gates and their routing logic in compact form, with detailed gate descriptions below only where behavior diverges from the common pattern.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | This skill is extremely verbose at ~300+ lines. It contains extensive procedural detail that could be dramatically compressed — the preference lookup chain is repeated nearly identically for G3 and G4, the CHANGE_RECORD.json generation section is overly detailed with field-by-field specifications, and many gate descriptions repeat patterns (AskUserQuestion, options, follow-up). Claude can infer most of this orchestration logic from a compact decision table. | 1 / 3 |
Actionability | The skill provides concrete decision gates, specific artifact paths to check, and clear routing logic with named sub-skills. However, it contains no executable code — all implementation is delegated to sub-skills via references. The state detection table and preference lookup chains are specific but not executable; they describe what to do rather than providing runnable commands or code snippets. | 2 / 3 |
Workflow Clarity | The workflow is exceptionally well-sequenced with a clear state detection table, numbered gates (G0-G5), explicit progress indicators at each step, preference-based branching with fallback logic, and error recovery paths. Validation checkpoints exist at each gate, and the resume/restart logic handles interrupted sessions. The complexity override at G4 is a thoughtful feedback loop. | 3 / 3 |
Progressive Disclosure | The skill references multiple sub-skills and external files (ensure-config.md, preferences-schema.md, CHANGE_RECORD_TEMPLATE.json) which is good progressive disclosure. However, the SKILL.md itself is monolithic — the nearly identical preference lookup logic for G3 and G4 should be extracted to a shared reference, and the CHANGE_RECORD.json field specifications could be in a separate reference file. No bundle files were provided to verify reference accuracy. | 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 | |
1fe948f
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.