code-simplifier
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.
76
66%
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 term coverage and good completeness, explicitly answering both what and when. Its main weaknesses are slightly abstract capability descriptions (could list more concrete refactoring actions) and moderate overlap risk with other code quality or review skills.
Suggestions
Add more concrete actions to improve specificity, e.g., 'Removes redundant logic, extracts reusable functions, simplifies conditionals, and improves naming conventions.'
Differentiate more clearly from general code review skills by emphasizing that this skill focuses specifically on simplification rather than bug-finding or performance optimization.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description names the domain (code simplification/refactoring) and mentions actions like 'simplifies', 'refines', and 'preserving functionality', but the actions are somewhat abstract rather than listing multiple concrete operations (e.g., extracting functions, renaming variables, removing dead code). | 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). | 3 / 3 |
Trigger Term Quality | Excellent coverage of 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 are highly natural phrases. | 3 / 3 |
Distinctiveness Conflict Risk | While the trigger terms are 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. | 2 / 3 |
Total | 10 / 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 with good before/after examples, but suffers from verbosity in its principles section and lacks concrete validation steps in its workflow. The guidance is more philosophical than actionable—it tells Claude what good simplification looks like but doesn't provide specific tool-based verification steps (e.g., running tests after refactoring). The persona framing at the top wastes tokens on something Claude doesn't need.
Suggestions
Remove the persona paragraph ('You are an expert...') and the HTML comment—Claude doesn't need to be told it's an expert, and the attribution adds no actionable value.
Add concrete validation steps to the refinement process, such as 'Run existing tests to confirm no behavioral changes' or 'Use diff to verify only structural changes were made'.
Trim the principles to focus on non-obvious guidance—remove items like 'Improving readability through clear variable and function names' that Claude already knows, and keep project-specific rules like 'Use ES modules' and 'Avoid nested ternaries'.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill includes some unnecessary framing ('You are an expert code simplification specialist...') and explains concepts Claude already understands (what clarity means, what redundant code is). The principles section has some padding but the examples are efficient. Could be tightened by ~30%. | 2 / 3 |
Actionability | The examples are concrete and executable TypeScript showing before/after patterns, which is good. However, the core guidance is largely principle-based rather than providing specific commands or tool usage patterns. The 'Refinement Process' is a high-level checklist without concrete steps (e.g., no specific commands for verification, no tool invocations). | 2 / 3 |
Workflow Clarity | The 6-step refinement process provides a sequence but lacks validation checkpoints. Steps like 'Verify the refined code is simpler' and 'Ensure all functionality remains unchanged' are stated but have no concrete verification mechanism (e.g., running tests, diffing outputs). For a refactoring skill that could introduce bugs, missing explicit validation/testing steps is a gap. | 2 / 3 |
Progressive Disclosure | The content is reasonably structured with clear sections (Principles, Process, Examples), but it's somewhat monolithic. It references CLAUDE.md for project standards (good), but the inline examples and lengthy principles could benefit from better organization. For its length (~80 lines of substantive content), it's acceptable but the principles section is heavy. | 2 / 3 |
Total | 8 / 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.
- Repository
- roman01la/skills-agents
- Commit
45417f2
- 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.