performance-profiling
/performance-profiling
Use when investigating a performance problem — slow endpoints, high latency, memory/CPU pressure, or N+1 queries. A measure-first method to find the real bottleneck and verify the gain, instead of guessing at optimizations.
- Author
- alisinadevelo ↗
- Repository
- md-files ↗
- Licence
- MIT
- Last repository change
- 03.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 03.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Use when investigating a performance problem — slow endpoints, high latency, memory/CPU pressure, or N+1 queries. A measure-first method to find the real bottleneck and verify the gain, instead of guessing at optimizations.
Original author description
Use when investigating a performance problem — slow endpoints, high latency, memory/CPU pressure, or N+1 queries. A measure-first method to find the real bottleneck and verify the gain, instead of guessing at optimizations.
How it works
- Method
- High-yield bottlenecks
- Discipline
SKILL.md preview
--- name: performance-profiling description: >- Use when investigating a performance problem — slow endpoints, high latency, memory/CPU pressure, or N+1 queries. A measure-first method to find the real bottleneck and verify the gain, instead of guessing at optimizations. --- # Performance Profiling The first rule: **measure before you optimize.** Intuition about where time goes is wrong often enough that acting on it wastes effort and risks making things slower. ## Method 1. **Define the metric and target.** Latency (p50/p95/p99), throughput, memory, CPU, or query count — and what "fast enough" is. No target means no way to know you're done. 2. **Reproduce and profile.** Trigger the slow path under realistic conditions and measure where time/resources go: a profiler/flame graph, request timing, query logs, `EXPLAIN ANALYZE`, allocation traces, a benchmark. Suspect, then confirm. 3. **Attack the dominant cost (Amdahl's law).** Optimizing a 5% cost caps your gain at 5%. Find and fix what dominates the profile. 4. **Re-measure with the same method.** Report before/after. A change with no measured improvement isn't an optimization — revert it. 5. **Guard against regression.** Note trade-offs (memory↔speed, cache invalidation, complexity). Consider a benchmark in CI for the hot path. ## High-yield bottlenecks - **N+1 queries** — a query per row in a loop → batch/eager-load. Usually the single biggest backend win. - **Missing/!used index** — full scans on a filtered/sorted column → add the right composite index in the right column order. - **Repeated work** — recomputing inside a loop what could be hoisted out, or caching what's stable (with an invalidation story). - **Wrong data structure** — O(n²) where a set/map gives O(n); linear scans of large lists. - **Serial I/O** — independent network/disk calls run sequentially → parallelize. - **Over-fetching / over-serializing** — pulling and marshalling data you discard. - **Allocation churn** — allocations in a hot loop → reuse buffers, reduce copies. ## Discipline - Don't micro-optimize cold paths or trade clarity for gains that don't move the metric. - Don't add caching without invalidation. - A faster wrong answer is still wrong — confirm behavior is unchanged. Premature optimization wastes time; *informed* optimization, targeted by measurement at the dominant cost, is one of the highest-leverage things you can do.
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · alisinadevelo/md-files | 100 | MIT |
| akillness/jeo-skills | 100 | MIT |
| MengTo/Skills | 100 | MIT |
| Reprograme/redevkit | 100 | MIT |
| HeshamFS/materials-simulation-skills | 100 | Apache-2.0 |
| charierefiedler/ronce-racine | 100 | MIT |
| Gattic/GatPi-Harness | 100 | MIT |
| reddygopalkrishna/developer-agent-skills | 100 | MIT |
| jeffersonvalente/cardume | 100 | MIT |
Database snapshot: 13.11.2026 · package version 6673a321e86f (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
- 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… - 100profiling-application-performance
Execute this skill enables AI assistant to profile application performance, analyzing cpu usage, memory consumption, and execution time. it is triggered when the user requests performance analysis, bottleneck identification, or optimization recommendations. the... Use when… - 100profiling-application-performance
Execute this skill enables AI assistant to profile application performance, analyzing cpu usage, memory consumption, and execution time. it is triggered when the user requests performance analysis, bottleneck identification, or optimization recommendations. the... Use when… - 100performance-expert
Expert performance optimization across CPU, memory, I/O, and rendering. Trigger keywords: performance, slow, profiling, profiler, optimize, latency, throughput, p99, memory leak, allocation, bottleneck, benchmark, flamegraph, N+1, cache. Use to diagnose and fix performance… - 100performance-optimization
Use when performance is a real concern — measure first, isolate the bottleneck, and prove the improvement instead of guessing - 100backend-performance-review
Reviews backend codebases for performance bottlenecks using an evidence-first, workload-driven methodology. Use when investigating latency, throughput, slow endpoints, database or query performance, N+1 queries, connection pool exhaustion, event-loop blocking, lock contention,…