Optimization
Use this skill when the task is about making a system faster, lighter, more scalable, or otherwise more efficient.
Core principle
To optimize properly, you must know:
- What metrics you are chasing
- What your real bottlenecks are
Do not optimize blindly.
1. Define the target metrics first
Before changing code, make sure you have the right measurements.
- Identify the exact metrics that matter: latency, throughput, memory, CPU, startup time, compile time, query count, token usage, cost, etc.
- Measure comprehensively, not just a convenient subset.
- Make sure the metrics are accurate and representative of the real workload.
- Prefer measurements that are fast to run so you can iterate quickly.
- If possible, create repeatable benchmarks or scripts so improvements are verifiable.
2. Get full bottleneck attribution
You should have strong attribution for what each part of the system is doing.
- Instrument the system so you can see where time and resources are going.
- Prefer both:
- Ad hoc inspection for quick debugging
- Logged measurements for later analysis and comparison
- Attribute work across the full path, not just the obviously slow component.
- Make sure the data is detailed enough to explain where the cost comes from.
If you can analyze runs after the fact with logs or traces, that is often much more powerful than relying only on live inspection.
3. Use static analysis too
Not every optimization problem needs runtime profiling first. Often, code inspection reveals the issue.
Check for:
- Wrong asymptotic complexity
- The wrong algorithm or data structure
- Unnecessary repeated work
- Work happening in the wrong layer
- Inefficient architecture or control flow
- Directionally incorrect approaches
Make sure your asymptotics are right and the overall algorithm makes sense before tuning small details.
4. Macro-optimize before micro-optimizing
Prioritize the largest wins first.
- Remove whole classes of work before making existing work slightly cheaper.
- Fix architecture, batching, caching, query patterns, algorithm choice, parallelism, and data movement before focusing on tiny low-level tweaks.
- If you are very far from the expected metrics, spend more time on macro-optimization.
Micro-optimizations matter most after the major inefficiencies are already addressed.
Recommended workflow
- Define success metrics.
- Reproduce the current baseline.
- Add measurement and attribution if missing.
- Identify the top bottleneck.
- Check for algorithmic or architectural issues.
- Apply the highest-leverage fix first.
- Re-measure.
- Repeat until the target is met or tradeoffs stop being worth it.
Guardrails
- Do not claim an optimization without before/after evidence.
- Be careful not to optimize the wrong metric.
- Watch for regressions in correctness, reliability, maintainability, and security.
- Prefer changes that are measurable, explainable, and reversible.
1---
2name: optimization
3description: Use when improving performance, latency, throughput, memory usage, or general efficiency. Start by defining target metrics, measuring comprehensively, attributing bottlenecks, validating with static analysis, and prioritizing macro-optimizations before micro-optimizations.
4allowed-tools: bash, read, write, grep, agentgrep, batch, todo
5metadata:
6 source: https://skillmd.com/skills/1jehuang/optimization
7---
8
9# Optimization
10
11Use this skill when the task is about making a system faster, lighter, more scalable, or otherwise more efficient.
12
13## Core principle
14
15To optimize properly, you must know:
16
171. **What metrics you are chasing**
182. **What your real bottlenecks are**
19
20Do not optimize blindly.
21
22## 1. Define the target metrics first
23
24Before changing code, make sure you have the right measurements.
25
26- Identify the exact metrics that matter: latency, throughput, memory, CPU, startup time, compile time, query count, token usage, cost, etc.
27- Measure **comprehensively**, not just a convenient subset.
28- Make sure the metrics are accurate and representative of the real workload.
29- Prefer measurements that are fast to run so you can iterate quickly.
30- If possible, create repeatable benchmarks or scripts so improvements are verifiable.
31
32## 2. Get full bottleneck attribution
33
34You should have strong attribution for what each part of the system is doing.
35
36- Instrument the system so you can see where time and resources are going.
37- Prefer both:
38 - **Ad hoc inspection** for quick debugging
39 - **Logged measurements** for later analysis and comparison
40- Attribute work across the full path, not just the obviously slow component.
41- Make sure the data is detailed enough to explain where the cost comes from.
42
43If you can analyze runs after the fact with logs or traces, that is often much more powerful than relying only on live inspection.
44
45## 3. Use static analysis too
46
47Not every optimization problem needs runtime profiling first. Often, code inspection reveals the issue.
48
49Check for:
50
51- Wrong asymptotic complexity
52- The wrong algorithm or data structure
53- Unnecessary repeated work
54- Work happening in the wrong layer
55- Inefficient architecture or control flow
56- Directionally incorrect approaches
57
58Make sure your asymptotics are right and the overall algorithm makes sense before tuning small details.
59
60## 4. Macro-optimize before micro-optimizing
61
62Prioritize the largest wins first.
63
64- Remove whole classes of work before making existing work slightly cheaper.
65- Fix architecture, batching, caching, query patterns, algorithm choice, parallelism, and data movement before focusing on tiny low-level tweaks.
66- If you are very far from the expected metrics, spend more time on macro-optimization.
67
68Micro-optimizations matter most after the major inefficiencies are already addressed.
69
70## Recommended workflow
71
721. Define success metrics.
732. Reproduce the current baseline.
743. Add measurement and attribution if missing.
754. Identify the top bottleneck.
765. Check for algorithmic or architectural issues.
776. Apply the highest-leverage fix first.
787. Re-measure.
798. Repeat until the target is met or tradeoffs stop being worth it.
80
81## Guardrails
82
83- Do not claim an optimization without before/after evidence.
84- Be careful not to optimize the wrong metric.
85- Watch for regressions in correctness, reliability, maintainability, and security.
86- Prefer changes that are measurable, explainable, and reversible.