Simplifies and refines code for clarity, consistency, and maintainability while preserving all functionality. Use when asked to "simplify code", "clean up code", "refactor for clarity", "improve readability", or review recently modified code for elegance. Focuses on project-specific best practices.
80
73%
Does it follow best practices?
Impact
90%
1.18xAverage score across 3 eval scenarios
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/code-simplifier/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.
This is a solid skill description with strong trigger terms and good completeness, explicitly covering both what the skill does and when to use it. Its main weakness is moderate specificity—it describes the goal (clarity, consistency, maintainability) rather than listing concrete refactoring actions. There's also some risk of overlap with general code review or refactoring skills.
Suggestions
Add more concrete actions to improve specificity, e.g., 'Extracts helper functions, removes redundant logic, simplifies conditionals, improves naming conventions'
Sharpen distinctiveness by clarifying what differentiates this from general code review—e.g., specify that this focuses on structural simplification rather than bug-finding or performance optimization
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (code simplification/refactoring) and describes the general action ('simplifies and refines code for clarity, consistency, and maintainability while preserving all functionality'), but doesn't list multiple concrete specific actions like removing dead code, extracting functions, renaming variables, etc. | 2 / 3 |
Completeness | Clearly answers both 'what' (simplifies and refines code for clarity, consistency, and maintainability while preserving functionality) and 'when' (explicit 'Use when...' clause with multiple trigger scenarios). Both components are well-articulated. | 3 / 3 |
Trigger Term Quality | Includes strong natural trigger terms users would actually say: 'simplify code', 'clean up code', 'refactor for clarity', 'improve readability', and 'review recently modified code for elegance'. These cover common variations of how users would phrase such requests. | 3 / 3 |
Distinctiveness Conflict Risk | While the trigger terms are fairly specific to code simplification, there's potential overlap with general code review skills, refactoring skills, or code quality skills. The phrase 'review recently modified code for elegance' could conflict with broader code review skills. The mention of 'project-specific best practices' is somewhat vague and could overlap with linting or style guide skills. | 2 / 3 |
Total | 10 / 12 Passed |
Implementation
64%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a solid code simplification skill with excellent concrete examples that clearly demonstrate the expected transformations. Its main weaknesses are some verbosity in the principles section (explaining things Claude already understands), and a workflow that lacks concrete validation steps for ensuring functionality is preserved during refactoring. The project-specific standards (ES modules, React patterns) may limit portability.
Suggestions
Add concrete validation steps to the refinement process, e.g., 'Run existing tests after changes' or 'Diff the output behavior before and after refactoring' to ensure functionality preservation is verified, not just stated.
Trim the persona preamble and obvious principles (e.g., 'Never change what the code does') - Claude understands these implicitly. Focus tokens on the non-obvious project-specific constraints and patterns.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill includes some unnecessary verbosity - the persona preamble ('You are an expert code simplification specialist...') tells Claude what it already knows, and some principles like 'Never change what the code does' are obvious. The project standards section references CLAUDE.md specifics that may not apply universally. However, the examples are reasonably tight. | 2 / 3 |
Actionability | The skill provides concrete, executable before/after TypeScript examples covering three distinct simplification patterns (nested ternaries, overly compact chains, redundant abstractions). The examples are copy-paste ready and clearly illustrate the expected transformation behavior. | 3 / 3 |
Workflow Clarity | The 6-step refinement process is listed but lacks validation checkpoints - there's no explicit verification step like running tests or diffing behavior. Steps like 'Verify the refined code is simpler' and 'Ensure all functionality remains unchanged' are vague without concrete methods. For a refactoring skill that could introduce bugs, missing concrete validation caps this at 2. | 2 / 3 |
Progressive Disclosure | The content is reasonably structured with clear sections (Principles, Process, Examples), but it's somewhat monolithic. The reference to CLAUDE.md for project standards is good progressive disclosure, but the inline examples and lengthy principles section could benefit from being split out if the skill grows. For its current size (~80 lines of content), the organization is adequate but not exemplary. | 2 / 3 |
Total | 9 / 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.
45417f2
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.