code-optimization

Optimize code performance through iterative improvements (max 2 rounds). Benchmark execution time and memory usage, compare against baseline implementations, and generate detailed optimization reports. Supports C++, Python, Java, Rust, and other languages.

Quality

55%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./.trae/openclaw-skills/code-optimization/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.

The body delivers a genuinely executable optimization workflow with concrete compile/profile/verify commands and a well-defined iteration budget, but it is significantly overweight. Generic best-practice and pitfall lists, duplicated report formats, and the absence of any bundle files to offload the large templates make it both verbose and monolithic.

Suggestions

Move the report template and worked example report into a references/report-template.md file and keep only a short pointer plus the required format fields inline.

Delete or drastically compress the generic "Best Practices", "Common Pitfalls", and stock profiling/compiler-flag sections, which restate knowledge Claude already has.

State the 2-iteration limit once prominently (e.g., in the constraints section) and remove the ~7 repeated restatements throughout, and add an explicit recovery step for when verification FAILs.

Dimension	Reasoning	Score
Conciseness	The ~380-line body includes several padded sections that restate knowledge Claude already has: generic "Best Practices" ("Measure First", "Consider Trade-offs"), generic pitfalls ("premature optimization"), stock profiling commands (perf, valgrind, -O3 -Wall), a full worked example report plus a near-duplicate blank template (~100 lines combined), and the 2-iteration limit repeated roughly eight times. This is noticeably verbose rather than merely having a few spots to tighten.	2 / 5
Actionability	Mostly executable guidance: concrete g++/rustc/javac invocations, sanitizer builds, and output-comparison commands (diff <(./reference) <(./optimized)). Steps 1 and 5, however, rely on pseudocode (read_file("topk_benchmark.cpp"), write_file(...)) that is not runnable, which keeps it below the fully copy-paste-ready 5 anchor.	4 / 5
Workflow Clarity	Five clearly sequenced steps with explicit stopping criteria and per-round correctness verification plus a "revert and stop" rule for regressions. It falls short of the 5 anchor because there is no error-recovery path when verification FAILs (e.g., fix and re-run), only performance-regression handling.	4 / 5
Progressive Disclosure	Sections are well organized with headers, but nothing is split out: a ~100-line report template and a full worked example report are inlined, and there are no bundle references at all. This matches the anchor for content that should be separate sitting inline despite reasonable structure, not the good-structure-with-clear-references anchor above.	3 / 5
	Total	13 / 20 Passed

Description

55%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.

The description communicates concrete capabilities in third person with a clear "what", and the explicit 2-round iteration limit is a useful distinguishing detail. Its main weaknesses are the complete absence of a "when to use" trigger clause and missing natural synonyms (e.g., "speed up", "profile"), leaving it at the capped completeness level.

Suggestions

Add an explicit trigger clause, e.g., "Use when the user asks to speed up, optimize, or profile code, or wants performance compared against a baseline (e.g., std::nth_element)."

Include natural user phrasings and synonyms such as "speed up", "faster", and "profile" alongside the existing technical terms.

Name the concrete optimization work (algorithm replacement, SIMD, concurrency) rather than the generic "iterative improvements" to sharpen distinctiveness.

Dimension	Reasoning	Score
Specificity	"Benchmark execution time and memory usage, compare against baseline implementations, and generate detailed optimization reports" lists several concrete third-person actions. The core activity itself ("iterative improvements") remains generic, so coverage is strong but not comprehensive enough for a 5.	4 / 5
Completeness	The "what" is clear (benchmark, compare against baseline, generate reports), but there is no "Use when..." clause or any equivalent trigger guidance, which the rubric says caps completeness at 3. It is not a 4 because the "when" is entirely missing rather than merely imprecise.	3 / 5
Trigger Term Quality	Relevant keywords are present ("optimize code performance", "benchmark", "memory usage", "baseline"), but natural user phrasings like "speed up my code", "faster", or "profile" are absent. This matches the anchor for some relevant keywords missing common variations or synonyms, not the good-coverage anchor above it.	3 / 5
Distinctiveness Conflict Risk	The performance/benchmark/baseline framing is somewhat specific, but "Optimize code performance... Supports C++, Python, Java, Rust, and other languages" is broad enough to overlap with general coding-assistant and benchmarking skills. It lacks the narrow niche triggers of the 4-5 anchors.	3 / 5
	Total	13 / 20 Passed

Validation

100%

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 — 16 / 16 Passed

Validation for skill structure

No warnings or errors.

Repository: huangruiteng/CS-Notes
Path: .trae/openclaw-skills/code-optimization/SKILL.md
Commit: 77c775d

Reviewed: 1 day 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.