| name | improve-skill |
| description | This skill should be used when the user asks to "improve a skill", "make this skill better", "add features to a skill", "this skill is missing something", "upgrade my skill", "what's missing from this skill", "the skill doesn't do X", "make this more useful", or wants to improve skill effectiveness rather than structural correctness. Not for structural fixes — use repair-skill. Not for agents.
|
| argument-hint | <path-to-skill-directory-or-SKILL.md> |
| allowed-tools | ["Read","Glob","Edit","Write","WebSearch","WebFetch","Task","AskUserQuestion"] |
Skill Improver
Increase the effectiveness of an existing skill by modeling user intent, testing the skill
against that intent through mental simulation and live doc validation, and proposing ranked
improvements — new features, UX gains, accuracy fixes, efficiency wins.
This skill is about whether the skill accomplishes what users need. Structural correctness
(malformed frontmatter, missing fields, violated conventions) is repair-skill's domain — if
obvious structural issues are present, note them briefly, recommend repair-skill, and
continue with effectiveness analysis.
Phase 0: Load the Skill
Read $ARGUMENTS as the path to a skill directory or SKILL.md file.
- If a directory: read
SKILL.md, then note which of references/, scripts/, examples/,
assets/ exist
- If a file: read it directly, then discover sibling resource directories
If the path is missing or ambiguous, use AskUserQuestion to resolve before proceeding.
Note any obvious structural issues in one sentence ("this description is first-person —
recommend repair-skill for structural fixes") and move on. Do not run a full structural audit.
Phase 0 is complete when SKILL.md is loaded and the sibling directory inventory is noted.
Phase 1: Understand User Intent
Before analyzing, establish what the user wants. Use AskUserQuestion:
- "What specifically does this skill not do well?"
- Offer options: a specific gap they've noticed, "I'm not sure — run a full effectiveness
audit", "it works but I want new capabilities", "the workflow feels clunky"
Regardless of the answer, also infer the skill's purpose from its description and body. State
your understanding of what problem it solves and for whom — one sentence — before proceeding.
This grounds the entire analysis in the correct frame.
If the user named a specific complaint: orient the analysis toward that area and scan for
related issues in the same workflow region. If the user is unsure: run the full Phase 2 audit
across all five sub-analyses.
Phase 1 is complete when user intent is established and the skill's purpose is stated.
Phase 2: Effectiveness Analysis
Load ${CLAUDE_PLUGIN_ROOT}/skills/improve-skill/references/effectiveness-rubric.md before
starting. It contains the severity framework, improvement type definitions, and effort/impact
calibration criteria used in Phase 3.
Run all five sub-analyses. For each finding record: what the issue is, why it reduces
effectiveness for the user, and the concrete improvement.
2a — Mental Simulation
Walk through the skill as Claude executing it with a concrete representative user request.
Choose an input that exercises the main workflow path — not an edge case, but the typical use.
For each phase of the skill, evaluate:
- Missing info: What does this step need that hasn't been provided or gathered yet? If the
user hasn't specified something and the skill doesn't ask, what does Claude have to guess?
- Divergence points: Where would two different Claude instances execute this instruction and
arrive at meaningfully different outputs? These are underspecified steps.
- Dead ends: Where does the skill's workflow stop but the user's actual goal isn't yet
accomplished? What does the user have to do manually after the skill finishes?
- Friction: Where does the skill pause the user at a low-value decision point (Claude could
make a good default), or skip user input at a high-value moment (user has a strong preference)?
Document findings by type: stuck points, divergence points, dead ends, friction points.
2b — Live Doc Validation
Identify all factual claims in the skill that reference external standards: frontmatter field
names, Claude tool names and behavior, API parameters, CLI flags, third-party service interfaces.
For each claim, verify against current documentation:
For Claude-specific claims (frontmatter options, tool names, model IDs):
Use Task tool with subagent_type=claude-code-guide — faster and more accurate than WebSearch.
For third-party claims (npm packages, APIs, external CLIs):
Use WebSearch or WebFetch against official documentation.
Flag drift between what the skill states and current reality. Severity: high if the claim
produces broken output; medium if it produces outdated guidance; low if it's a naming change
with no behavioral difference.
2c — Feature Adjacency Scan
Given the skill's purpose, identify capabilities that are absent but would be high-value:
- Adjacent: Naturally extends what the skill already does — same domain, one step further.
The user who just ran this skill would almost certainly want this next.
- Complementary: Commonly needed right before or after this skill. The user does this
manually today.
- End-to-end gap: The skill starts a job the user finishes by hand — workflow stops at
"here's a plan" when the user wanted "and apply it."
For each candidate: estimate implementation effort (one instruction change, new phase, or new
script) and user value (rare edge case, common scenario, or blocks the skill in a key scenario).
2d — UX Flow Review
Evaluate the skill's interaction design:
- Does the skill surface all necessary questions at the start (before heavy work), or does it
interrupt mid-workflow with requests the user didn't anticipate?
- Is the "I don't know" path explicit? If a user triggers the skill without a specific
complaint, does the skill handle that gracefully, or does it assume the user knows?
- Does the output format match how users consume it? A report users read once can be dense
prose; one they apply iteratively needs more structure.
- Are there steps where the skill makes a consequential decision without user input?
2e — Edge Case Stress Test
After walking the main path (2a), deliberately try to break the skill. Identify 3–5
adversarial inputs that test failure modes:
- Missing or malformed input: What happens when expected files don't exist, paths are
wrong, or arguments are empty/garbled?
- Contradictory requirements: What if the user's stated goal conflicts with their input
(e.g., "improve this skill" on a file that isn't a skill)?
- Unsupported configurations: What if the skill encounters a structure it wasn't designed
for — a different framework version, an edge-case project layout, an unexpected file format?
- Boundary conditions: What if the input is very large (500-line SKILL.md), very small
(empty file), or has unusual characters in paths/names?
For each adversarial input, evaluate: does the skill detect the problem and surface a useful
error, silently produce wrong output, or crash the workflow? Map findings to improvement
types: missing error handling → NEW FEATURE, poor failure message → UX IMPROVEMENT,
undetected bad state → ACCURACY FIX.
Phase 2 is complete when all five sub-analyses are finished and findings are recorded.
Phase 3: Improvement Proposal
Load ${CLAUDE_PLUGIN_ROOT}/skills/improve-skill/references/effectiveness-report-template.md
for the output format before constructing the report. Reference
${CLAUDE_PLUGIN_ROOT}/skills/improve-skill/examples/sample-analysis.md to calibrate depth
and specificity if needed.
Present findings grouped by improvement type — users think in terms of outcomes, not audit
dimensions. Each entry must include: the sub-analysis code in brackets, what the gap is, why
it matters to the user, and the specific fix. Calibrate severity using the criteria in
references/effectiveness-rubric.md.
Ask: "Apply all improvements? Or select specific ones?"
Phase 3 is complete when the report is delivered and user selection is confirmed.
Phase 4: Apply Improvements
Apply confirmed items in order: new features → accuracy fixes → UX improvements →
efficiency gains.
For each item:
- State what is being changed and why — reference the effectiveness principle, not "you asked"
- Make the edit or create the file
- Confirm the change integrates cleanly with surrounding content
After applying, briefly explain:
- What was changed and why
- What was added and why
- What was left out and why (effort outweighs benefit, or requires domain knowledge the
user must supply)
- What was not selected — note it remains available to apply later
Validation: After delivering the explanation, re-read the modified SKILL.md in full and
confirm: all selected improvements are present, no surrounding content was inadvertently
altered, phases are still numbered with exit conditions, and all references point to files
that exist.
Phase 4 is complete when all confirmed items are applied, the explanation is delivered, and
the validation pass finds no integration failures.
Phase 5: Structural Lint
After applying effectiveness improvements, invoke the skill-lint agent for a structural
quality pass:
Use Task tool with subagent_type=claude-skills:skill-lint:
"Lint the skill at <path-to-skill-directory>. Auto-apply critical and major fixes, report
minor findings for user decision."
Wait for the agent to complete. If it auto-applied structural fixes, note them alongside
the effectiveness changes from Phase 4. If it reports minor findings, present them to the
user.
Phase 5 is complete when the lint agent returns and any user-selected minor fixes are applied.
