code-optimizer

Analyzes and optimizes code for better performance, memory usage, and efficiency. Use when code is slow, memory-intensive, or inefficient. Supports Python and Java optimization including execution speed improvements, memory reduction, database query optimization, and I/O efficiency. Provides before/after examples with detailed explanations of why optimizations work, complexity analysis, and measurable performance improvements.

1.06x

Quality

72%

Does it follow best practices?

Impact

87%

1.06x

Average score across 3 eval scenarios

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./skills/code-optimizer/SKILL.md

Quality

Content

56%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

A thorough, code-rich skill body with strong actionability and a clear multi-step workflow including validation, but it is weighed down by verbose explanations of elementary programming concepts Claude already knows and by progressive-disclosure issues: the cited reference files are missing and their intended detail is inlined.

Suggestions

Trim the "Common Optimizations" and "Best Practices" sections to only non-obvious guidance; remove basic explanations (list comprehensions vs loops, sum() being faster, sets being O(1), StringBuilder) that Claude already knows.

Create the referenced files (references/python_optimizations.md, references/java_optimizations.md, references/database_optimizations.md) and move the inlined per-language optimization examples there, keeping SKILL.md a lean overview.

Add an explicit failure-recovery feedback loop for destructive/batch optimizations (e.g. "if correctness validation fails, revert the change and re-profile") to elevate workflow clarity.

Dimension	Reasoning	Score
Conciseness	Noticeably verbose: the "Common Optimizations" section and 10-item "Best Practices" extensively explain concepts Claude already knows (list comprehensions beat loops, sum() is faster, sets are O(1), StringBuilder for concatenation, "avoid premature optimization"), padding the body well beyond what earns its place. It is above a 1 because the before/after templates and measurement code add real value, but the redundant elementary explanations pull it down rather than up.	2 / 5
Actionability	Mostly executable guidance with concrete before/after code (list comprehensions, generators, StringBuilder, N+1 fix, batch inserts) and copy-paste measurement tooling (cProfile, timeit, memory_profiler, System.nanoTime). Minor gaps keep it below 5: the optimization template uses placeholders like `[language]`, `[original code]`, and estimated gains like "100x faster" are asserted without a measurement harness.	4 / 5
Workflow Clarity	Clear two-track sequence (Optimization Workflow: Identify → Categorize → Propose → Measure/Validate, and Optimization Process: Profile → Hot Paths → Measure → Maintain) with a validation checklist (correctness, performance, memory, edge cases) and before/after comparison code. It is not a 5 because the validation is a checklist rather than an explicit failure-recovery feedback loop (e.g. "if correctness fails, revert and re-profile"), and batch/destructive operations benefit from such a loop.	4 / 5
Progressive Disclosure	Section structure is reasonable and references are clearly signaled one level deep ("See `references/python_optimizations.md`"), but the referenced files do not exist in the bundle and the bulk "Common Optimizations" detail is inlined in SKILL.md rather than split into those reference files — so structure is present with real organization gaps, the 3 anchor.	3 / 5
	Total	13 / 20 Passed

Description

88%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

A strong, third-person description that clearly states both capabilities and explicit trigger conditions with concrete actions across multiple optimization domains. The main gap is trigger-term synonym breadth, which keeps it just short of perfect.

Dimension	Reasoning	Score
Specificity	Lists multiple concrete actions across the domain — "execution speed improvements, memory reduction, database query optimization, and I/O efficiency" plus "before/after examples", "complexity analysis", and "measurable performance improvements" — giving comprehensive coverage rather than the 1-2 actions of a 3 or the minor gaps of a 4.	5 / 5
Completeness	Explicitly answers both what ("Analyzes and optimizes code for better performance, memory usage, and efficiency") and when ("Use when code is slow, memory-intensive, or inefficient") with concrete trigger phrases, matching the 5 anchor.	5 / 5
Trigger Term Quality	Includes natural user phrases like "code is slow, memory-intensive, or inefficient", but misses common variations users actually say ("make this faster", "optimize this function", "reduce memory") and has no synonym breadth, so it sits below the comprehensive coverage of a 5.	4 / 5
Distinctiveness Conflict Risk	Has a clear niche (performance/memory optimization for Python and Java) but "optimizes code" is broad enough to overlap with related refactoring or code-review skills, so it is mostly distinct with minor overlap risk rather than a 5.	4 / 5
	Total	18 / 20 Passed

Validation

87%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 14 / 16 Passed

Validation for skill structure

Criteria	Description	Result
skill_md_line_count	SKILL.md is long (542 lines); consider splitting into references/ and linking	Warning
referenced_paths_exist	Referenced path issues: 6 missing	Warning

	Total	14 / 16 Passed

Repository: ArabelaTso/Skills-4-SE
Path: skills/code-optimizer/SKILL.md
Commit: 4f38503

Reviewed: 10 days ago

Table of Contents

Discovery Implementation Validation

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.