simplify
Simplify and refine recently modified code for clarity and consistency. Use after writing code to improve readability without changing functionality.
Overall
score
63%
Does it follow best practices?
If you maintain this skill, you can automatically optimize it using the tessl CLI to improve its score:
npx tessl skill review --optimize ./path/to/skillValidation for skill structure
Discovery
67%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 has good structure with explicit 'what' and 'when' clauses, earning high marks for completeness. However, it lacks specific concrete actions (what exactly does 'simplify and refine' mean?) and could benefit from more natural trigger terms users would actually say. The scope is somewhat generic and could conflict with other code quality-related skills.
Suggestions
Add specific concrete actions like 'rename variables for clarity, extract repeated logic into functions, simplify conditionals, improve formatting'
Include more natural trigger terms users would say: 'clean up', 'refactor', 'polish', 'tidy up my code', 'make this cleaner'
Clarify what distinguishes this from general refactoring or code review skills - perhaps emphasize it's for cosmetic/readability changes only, not structural refactoring
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (code) and some actions ('simplify', 'refine', 'improve readability'), but lacks specific concrete actions like 'rename variables', 'extract functions', 'remove duplication'. The phrase 'clarity and consistency' is somewhat vague. | 2 / 3 |
Completeness | Clearly answers both what ('Simplify and refine recently modified code for clarity and consistency') and when ('Use after writing code to improve readability without changing functionality'). The explicit 'Use when...' clause provides clear trigger guidance. | 3 / 3 |
Trigger Term Quality | Includes some relevant terms like 'code', 'readability', 'clarity', but misses common variations users might say such as 'clean up', 'refactor', 'polish', 'tidy', 'simplify my code', or 'make code cleaner'. | 2 / 3 |
Distinctiveness Conflict Risk | Could potentially overlap with general code review skills, refactoring skills, or linting skills. The 'recently modified code' qualifier helps somewhat, but 'clarity and consistency' is broad enough to conflict with other code quality skills. | 2 / 3 |
Total | 9 / 12 Passed |
Implementation
50%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill provides a reasonable framework for code simplification but relies heavily on abstract principles rather than concrete, executable guidance. It lacks before/after code examples that would make the guidance actionable, and the workflow lacks validation steps to ensure refactoring doesn't break functionality. The content could be more concise by removing self-referential language about expertise.
Suggestions
Add 2-3 concrete before/after code examples demonstrating the simplification principles (e.g., nested ternary → switch statement, arrow function → function keyword)
Include a validation step in the workflow such as 'Run tests after refactoring' or 'Compare outputs before and after changes'
Remove self-referential language like 'Your expertise lies in...' and 'as a result of your years as an expert' - Claude doesn't need this framing
Consider extracting the detailed coding standards list to a separate reference file since they're already in CLAUDE.md
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The content includes some unnecessary verbosity like 'Your expertise lies in mastering...' and 'as a result of your years as an expert software engineer' which don't add actionable value. The principles are mostly relevant but could be tightened. | 2 / 3 |
Actionability | Provides guidelines and principles but lacks concrete code examples showing before/after refactoring. The 'refinement process' is a high-level checklist rather than executable steps with specific commands or code patterns. | 2 / 3 |
Workflow Clarity | Lists a 6-step refinement process but lacks validation checkpoints or feedback loops. No guidance on how to verify functionality is preserved or what to do if refactoring introduces issues. | 2 / 3 |
Progressive Disclosure | Content is reasonably organized with numbered sections, but references CLAUDE.md without clear signaling of what's there vs. here. Could benefit from separating detailed coding standards into a reference file. | 2 / 3 |
Total | 8 / 12 Passed |
Validation
75%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 12 / 16 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
description_trigger_hint | Description may be missing an explicit 'when to use' trigger hint (e.g., 'Use when...') | Warning |
metadata_version | 'metadata' field is not a dictionary | Warning |
license_field | 'license' field is missing | Warning |
body_examples | No examples detected (no code fences and no 'Example' wording) | Warning |
Total | 12 / 16 Passed | |
- 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.