Fix Measured Bottlenecks with ln-31 Performance Optimizer

Where this fits

A developer has just spotted a regression: p95 latency on the checkout endpoint jumped from 240 ms to 620 ms after the latest release. A generic make it faster prompt is dangerous because teams often start optimizing before knowing where the time goes. This skill fits the moment after you have a measured bottleneck and need an agent that profiles, isolates a change, measures the same metric again, and keeps or discards the change based on evidence.

Why agents benefit

• Starts from evidence: it ignores vague optimization requests and only acts on a measured latency, throughput, memory, CPU, or I/O problem.
• Isolates one variable at a time: each experiment changes a single suspected cause and compares before/after metrics, so you get keep-or-discard decisions instead of claim piles.
• Defends correctness: the execution contract requires resolving every checklist item as PROVEN, CLEARED, or UNPROVEN, so regressions and unproven assumptions surface explicitly.
• Has explicit tool routing: the skill routes profiling and experimental tasks to preferred tools, not ad-hoc commands chosen mid-task.
• Not an A/B substitute: it stays in its lane, avoiding the false pretense of unbiased comparison when that is not what you asked for.

Practical scenarios

API p95 latency regression

After a dependency upgrade, /search p95 goes from 210ms to 480ms. The agent uses the skill to profile the request path, flags an N+1 query introduced by the ORM change, runs a keep-or-discard experiment with a single query batch, and reverts when evidence does not prove a stable improvement.

Batch worker memory ceiling

A nightly export job is OOM-killed at 1.2 GB heap. The skill profiles allocation sites, tests a bounded buffer and an off-heap cache as separate experiments, keeps only the change that reduces steady-state memory below the 1 GB limit without increasing runtime.

I/O bottleneck in a bulk upload flow

A file ingestion endpoint is CPU idle but disk-bound. The agent profiles system calls, introduces a prefetch buffer, and measures throughput before/after. It discards the prefetch when it shows no consistent improvement, leaving the original code intact.

Add it to your agent workflow

Install with:

npx skills add levnikolaevich/claude-code-skills --skill ln-31-performance-optimizer

Then ask your agent to use the skill only after a metric is pinned. Example:

Use ln-31-performance-optimizer to profile the /search endpoint. p95 latency regressed from 210 ms to 480 ms after the last release. Suspected cause: pagination query. Optimize without changing the API contract.

The skill will produce a checklist with measured evidence, a keep-or-discard verdict, and a list of unresolved items before you approve the final change.

Compare before adopting

Compare this skill against ad-hoc performance prompts, language-specific profilers, and custom optimization workflows. Look at quality signals: does it demand proof of correctness and regressions? Does it make ambiguous items explicit rather than hidden? Check maintenance freshness: the repository has 556 stars, but also review recent commits, open issues, and whether installed tool dependencies are current. Alternatives might fit better if you need unbiased A/B testing or a language-specific optimizer rather than a general measured-bottleneck workflow.

Why it is worth tracking

This skill is worth tracking because it encodes the missing discipline in AI-assisted performance work: optimize only measured problems, prove each change, and keep only what survives evidence. At OpenAgentSkill, the record for this skill at https://www.openagentskill.com/skills/levnikolaevich-ln-31-performance-optimizer tracks community momentum and maintenance signals, which matters as new profilers and agent toolchains appear. Evaluate it when you feel the first regression, then judge it on whether it reduces guesswork across many runs without adding checklist ceremony.