17 skills · category

Performance skills for Claude Code

Skills for finding and fixing slowness with evidence: Core Web Vitals at p75, bundle analysis, React re-renders, Node and Python profiling, memory leaks, HTTP and CDN caching, image delivery, N+1 queries, async concurrency, and Lighthouse budgets enforced in CI.

Download all 17 (.zip) Browse the list

Every performance skill

Each card opens the full playbook, example prompts and install commands.

No. 293

Async Concurrency

Parallel I/O with limits, timeouts, and backpressure

Claude turns sequential awaits into concurrent work without overloading anything: it finds the binding limit (rate limit, DB pool, memory), derives a cap from throughput times latency, and implements bounded fan-out in TypeScript, Python or Go with timeouts, cancellation and per-item error handling. Retries use jittered backoff and producers get real backpressure.

async-concurrency 209 lines

No. 294

Bundle Analysis

Cut the initial JS users actually download

Claude measures before cutting: compressed size of the initial route, a treemap of what is in it, and a classification of every big module as needed now, needed later, duplicated or dead. It then removes, lazy-loads, replaces or tree-shakes in that order, proves the gain with the same build command, and adds a dependency-free budget script to CI so size cannot creep back.

bundle-analysis 184 lines · 2 files

★ No. 295

Core Web Vitals

Fix the sub-part that is actually slow

Claude starts from field data at the 75th percentile, not a Lighthouse score, and splits the failing metric into its sub-parts: TTFB and load delay for LCP, input delay and processing for INP, the shifting element for CLS. It then applies the one fix that targets the dominant sub-part, verifies it under matching throttling, and tells you when CrUX will reflect the change.

core-web-vitals 190 lines · 2 files

No. 296

Go pprof Profiling

The profile picks the hot path; benchstat judges the fix

Claude matches the symptom to the right Go profile, collects it from benchmarks or a pprof endpoint kept off the public listener, and reads it with top, list and flame graphs to find allocation, contention or I/O costs. Fixes are judged with benchstat across ten runs and a profile diff, not by eyeballing one benchmark, and runtime knobs come only after code changes.

go-pprof 212 lines

No. 297

HTTP Caching

Year-long assets, always-fresh HTML, zero leaks

Claude writes a caching policy per response class instead of tweaking headers file by file: fingerprinted assets cached for a year as immutable, HTML revalidated on every load, shared APIs held at the CDN with stale-while-revalidate, and anything personalized marked private. A bundled checker audits live URLs, confirms 304 revalidation and flags public responses that set cookies.

http-caching 163 lines · 2 files

No. 298

Image Optimization

Right size, modern format, loaded at the right time

Claude fixes images in the order that saves the most bytes: dimensions first, then format, then loading behavior. It generates width variants with sharp or an image CDN, writes srcset and sizes that match the real layout, gives the hero fetchpriority instead of lazy loading, and adds dimensions everywhere. A bundled auditor flags markup mistakes in rendered HTML.

image-optimization 176 lines · 2 files

No. 299

JVM Tuning

GC logs and JFR first, then a short flag set with reasons

Claude starts by recording the JDK version, collector, heap, container limits and a stated latency goal, then gathers GC logs and a Flight Recorder capture under real load. It classifies the problem, such as humongous allocations, an undersized heap, native memory overrun or CPU throttling, fixes allocation causes before flags, and ends with a short flag set where every entry has a reason.

jvm-tuning 183 lines · 2 files

★ No. 300

Lighthouse CI

Fail the PR when pages get slower, not later

Claude adds Lighthouse CI that teams keep enabled: it baselines key pages over several runs, asserts on LCP, TBT, CLS and byte weight using median aggregation instead of a volatile score, wires autorun into GitHub Actions or GitLab after the production build, and controls noise from shared runners and third-party scripts. Thresholds start at today's numbers and tighten after each win.

lighthouse-ci 173 lines · 2 files

No. 301

Memory Leak Hunting

From growing heap to the exact retaining reference

Claude separates real leaks from warming caches by repeating one action with forced GC, then uses the three-snapshot comparison to find object types that grow per round. It follows the retainer chain to the first reference your code owns, such as a listener, timer, unbounded Map or uncleaned effect, fixes it, and reruns the same loop to show flat memory.

memory-leak-hunting 159 lines · 2 files

No. 302

N+1 Queries

Query counts that stay flat as data grows

Claude counts queries per request before touching code, finds the repeated statement that differs only by ID, and traces it to the serializer, template or resolver that triggers it. It picks join loading for to-one relations, separate IN queries for collections, SQL aggregates for counts and DataLoader for resolvers, then adds a test that fails if the count grows again.

n-plus-one-queries 218 lines

No. 303

Node.js Profiling

Flamegraphs and event loop lag, not guesses

Claude reproduces the slowdown with a load test, classifies it as CPU-bound, event-loop blocking, I/O wait or GC pressure using event loop utilization and lag percentiles, then captures the matching profile with Node's built-in flags. It reads flamegraphs by self time, fixes the specific hot path, and reports before and after p99 latency from the identical load run.

node-profiling 183 lines

No. 304

Python Profiling

Find the slow line before rewriting anything

Claude sets up a fixed benchmark with an output hash, picks the profiler that fits the situation (cProfile for scripts, py-spy for live processes, pyinstrument for async, memray for memory), and classifies the bottleneck before touching code. Fixes follow payoff order: data structures, vectorization, caching, then processes or compiled extensions, with identical output verified.

python-profiling 194 lines

No. 305

React Re-renders

Profile first, memoize last

Claude profiles the slow interaction in a production build, names the components whose commits dominate and why each rendered, then fixes structure first: moving state down, passing children, splitting context, using store selectors. Memoization, transitions and virtualization come only where the profiler shows they pay off, and React Compiler adoption follows its lint rules.

react-rerenders 199 lines

★ No. 306

Rendering Strategies

Static where you can, per-request only where you must

Claude inventories every route first: data sources, how stale each may be, whether it is per-user, traffic share and page count. It then picks the most static mode the facts allow, maps it to the framework's real config, keeps personalized bits out of shared caches, and proves the plan with build output, cache-hit headers and a cross-user leak test.

rendering-strategies 207 lines

No. 307

TTFB Optimization

Find the slow phase of the first byte, then fix only that

Claude measures before it optimizes: field TTFB per route, then a curl-based script that splits each request into DNS, TCP, TLS, server wait and download and reads Server-Timing. Only then does it pick the fix that matches the dominant phase, such as edge caching, removing redirect chains, co-locating compute with the database or parallelizing upstream calls.

ttfb-optimization 180 lines · 2 files

No. 308

Web Font Loading

Fonts that arrive early and move nothing when they swap

Claude audits which font files load and when, cuts unused weights, self-hosts and subsets to WOFF2 with unicode-range, and preloads only the file the first screen needs. A bundled stdlib script reads the font's own metric tables and prints a fallback @font-face with size-adjust and ascent/descent overrides, so the swap from Arial to the web font reflows nothing.

web-font-loading 230 lines · 2 files

No. 309

Web Workers

Get heavy computation off the main thread, measured

Claude starts from a Performance recording, not a hunch. It confirms that a long task is pure computation, tries yielding first, then moves the work into a worker that owns its data. A bundled script measures structured-clone and transfer cost for your real payload, and the skill covers Comlink RPC, stale-result guards, OffscreenCanvas and the exact new Worker(new URL(...)) form that Vite and webpack detect.

web-workers 230 lines · 2 files

Choosing Performance skills

Install the skills that match requests you make every week; each costs about 100 tokens of standing context until it loads. If you are not sure where to begin, start with Core Web Vitals, Lighthouse CI and Rendering Strategies. For background, read The Best Claude Code Skills in 2026, by Use Case, How to Install Claude Code Skills (5 Ways) and Personal vs Project Skills.

By technology: JavaScript skills Python skills Next.js skills

Install several

Install several at once

The installer accepts any number of skill names. Add --project to install into the current repository.

curl -fsSL https://claudeskills.page/install.sh | sh -s -- async-concurrency bundle-analysis core-web-vitals go-pprof http-caching image-optimization jvm-tuning lighthouse-ci memory-leak-hunting n-plus-one-queries node-profiling python-profiling react-rerenders rendering-strategies ttfb-optimization web-font-loading web-workers

Performance skills FAQ

How do I install every Performance skill at once?

Download the bundle at https://claudeskills.page/downloads/category/performance.zip and unzip it into ~/.claude/skills/ (or .claude/skills/ inside a repository). To pick a few, pass several names to the installer: curl -fsSL https://claudeskills.page/install.sh | sh -s -- async-concurrency bundle-analysis core-web-vitals.

Will installing 17 skills slow Claude Code down?

No. Claude Code keeps only each skill's short description in context — roughly 100 tokens per skill — and loads the full instructions only when a request matches. Install the whole category if it fits your work; unused skills cost almost nothing.

Which Performance skill should I start with?

Start with Core Web Vitals, Lighthouse CI, Rendering Strategies. They cover the most common requests in this category; add the rest as your work calls for them.