Skip to content
Skills Library
Programming · Analysis

optimize

/optimize

Use for performance work. Measure-first, profile-driven. Refuses to optimise without a baseline measurement. Targets the actual hotspot, not where intuition says it is.

Repository
sift-coder ↗
Licence
MIT
Last repository change
03.06.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 03.06.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use for performance work. Measure-first, profile-driven. Refuses to optimise without a baseline measurement. Targets the actual hotspot, not where intuition says it is.

Original author description

Use for performance work. Measure-first, profile-driven. Refuses to optimise without a baseline measurement. Targets the actual hotspot, not where intuition says it is.

How it works

  1. Method
  2. Output shape
  3. Rules
  4. Anti-patterns
  5. When NOT to use
  6. Subagent dispatch
  7. Value over native CC
Original SKILL.md headings · 68 lines, 396 words
SKILL.md preview
---
name: optimize
description: Use for performance work. Measure-first, profile-driven. Refuses to optimise without a baseline measurement. Targets the actual hotspot, not where intuition says it is.
---

# optimize

Measure. Find the hotspot. Optimise the hotspot. Re-measure. Stop.

## Method

1. **Baseline.** Reproduce the slowness with a deterministic command. Record:
   - Wall time, CPU time, memory, allocations, query count, network calls (whichever apply)
   - Example input characteristics
2. **Goal.** State a numeric target. "Faster" is not a goal. "p95 < 200ms" is.
3. **Profile.** Use the right tool for the language:
   - Node: `--prof`, clinic.js, 0x
   - Python: cProfile, py-spy, scalene
   - Apex: Salesforce debug log analysis (`/siftcoder:sf-debug`)
   - SQL: EXPLAIN ANALYZE
   - Browser: DevTools Performance tab
4. **Identify the actual hotspot.** Often surprising. Optimising elsewhere is wasted.
5. **Hypothesise the fix.** State why it should help, by how much.
6. **Apply minimal change.**
7. **Re-measure.** If improvement is real and meets the goal — stop. If not, revert and try another hypothesis.
8. **Regression test.** Add a perf test (with reasonable tolerance) so you don't lose the win.

## Output shape

```
Goal:         <numeric target>
Baseline:     <metric snapshot>
Profile:      <hotspot identified — function or query, w/ %>
Hypothesis:   <fix description, expected gain>
Change:       <diff>
After:        <new metric snapshot>
Improvement:  <delta>
Status:       ✓ goal met | ✗ goal not met (revert)
```

## Rules

- **No optimisation without baseline.** "Faster" is not measurable.
- **No optimisation without profiling.** Intuition is wrong about hot paths >50% of the time.
- **Goal is numeric.** P95, throughput, memory, query count.
- **Revert if the change doesn't move the metric.** Speculative optimisations rot the code.
- **Add a perf test for the win.** Otherwise it regresses silently in 6 months.

## Anti-patterns

- "Cleaner code is faster" — sometimes, often not
- Caching without measuring cache hit rate
- Async-ifying sync code that wasn't blocking
- Premature optimisation in code that runs once a day
- Micro-optimising at the expense of readability when the macro problem is unsolved

## When NOT to use

- Refactoring for clarity (no perf goal) — `/siftcoder:refactor`
- Deleting code (smaller is better but not perf-driven) — `/siftcoder:zen`
- Bug fix — `/siftcoder:fix`

## Subagent dispatch

- `general-purpose` for targeted optimisation work
- `investigator` for read-only profiling diagnosis
- For Salesforce: `/siftcoder:sf-debug parse <log>` — dedicated debug-log analysis

## Value over native CC

CC will optimise on request. CC won't naturally insist on baseline + profile + numeric goal + revert-if-no-improvement. This skill enforces the discipline that distinguishes real optimisation from cargo-cult.

Versions

RepositoryScoreLicence
This page · ialameh/sift-coder100MIT
flavien-ia/hypervibe-craft100Apache-2.0
marcel-bich/marcel-bich-claude-marketplace100MIT
joris887/exosuit100MIT
tmih06/ompig-slim100MIT
gosuda/dalcom-skills100Apache-2.0
wwylon/devkit100MIT
precedentlabs/skill-library100MIT
sebbsssss/optimize-skill100MIT

Database snapshot: 13.11.2026 · package version 560081e6ce13 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100perf
    The general profile-driven perf loop for any language or runtime: baseline, profile, fix the real hot path, re-measure. Use for /perf, "this is slow", or optimization work.
  • 90hotspot-analysis
    How to read a fast-kernel profile (module attribution, kernel counts, GPU-busy ratio, roofline boundness) and turn it into the next hypothesis from the measured headroom. Use when deciding what to optimize next.
  • 100performance-pass
    Fixes measured slowness by setting a budget, profiling to find where time actually goes, changing one thing, and measuring again. Use for a latency regression, an N+1 query, memory growth, a slow build or test suite, or a Core Web Vitals miss. Refuses to optimize anything without a baseline number.
  • 90Optimization
    Measure-first performance optimization playbook — profiling discipline, bottleneck triage (CPU/memory/I/O), caching layers, and the algorithm/DB/frontend/network fix patterns. Use when the user reports something is slow ("dashboard takes forever", "API is laggy", "bundle is…
  • 100performance-tuning
    Make software faster by measuring first and changing the thing that dominates. Use when the user says something is slow, asks how to optimise or speed up code, a page, an API or a service, asks about profiling, caching, latency, p99, throughput, memory usage, OOM, CPU at 100…
  • 100performance-optimization
    Use when performance is a real concern — measure first, isolate the bottleneck, and prove the improvement instead of guessing

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.