Skip to main content
skill CX Codex

performance-analysis · rsmdt — Claude Code skill: what it does, how to install

performance-analysis applies systematic profiling to find bottlenecks across CPU, memory, and database layers. It enforces measuring baselines before proposing optimizations.

MIT ★ 587 updated 2026-10-26

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add rsmdt/the-startup
/plugin install team@the-startup
Open on GitHub

What performance-analysis does

Profiles systems across application, system, and infrastructure tiers. It relies on the USE pattern to inspect resource utilization, saturation, and errors, alongside the RED pattern for request rate, error counts, and latency spreads. Discovered bottlenecks fall into concrete categories like CPU loops, lock contention, memory leaks, and N+1 database queries.

Optimization ordering follows Amdahl's Law. It targets components taking the bulk of execution time rather than trivial code paths. Latency analysis explicitly demands percentiles such as p50, p95, and p99 instead of simple averages.

The skill will not accept optimizations without empirical baseline data gathered from production-like infrastructure. If a solution introduces caching, defining a cache invalidation strategy is strictly mandatory.

What it helps with

  • trace application bottlenecks across CPU, memory, and I/O
  • diagnose N+1 queries and slow database latency
  • measure tail latency regressions using p95 and p99 percentiles
  • formulate validation plans to verify optimization impact

Example prompts for the agent

  • Profile the checkout API endpoint to locate high p99 latency causes
  • Diagnose memory growth and GC pressure in our worker service
  • Investigate lock contention and connection pool exhaustion in PostgreSQL

How to install performance-analysis

1Plugin marketplace

/plugin marketplace add rsmdt/the-startup
/plugin install team@the-startup

This installs the whole team plugin with all its skills

2Skills CLI (Vercel)

npx skills add rsmdt/the-startup --skill performance-analysis -a claude-code

3Manually: put the files in place

~/.claude/skills/performance-analysis/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/performance-analysis/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about performance-analysis

How to install performance-analysis in Claude Code?

Run these two commands in Claude Code: first /plugin marketplace add rsmdt/the-startup, then /plugin install team@the-startup.

What does performance-analysis do?

It guides Claude Code to act as a performance engineer, measuring baselines, classifying bottlenecks with USE and RED methods, and prioritizing fixes by Amdahl's Law.

What constraints does the skill enforce during profiling?

It forbids optimizing without measured baseline evidence and rejects using averages for latency, requiring percentiles like p50, p95, and p99. Profiling must also happen in production-like environments.

Source text

SKILL.md · MIT
---
name: performance-analysis
description: Measurement approaches, profiling patterns, bottleneck identification, and optimization guidance. Use when diagnosing performance issues, establishing baselines, identifying bottlenecks, or planning for scale. Always measure before optimizing.
---

## Persona

Act as a performance engineer who applies systematic measurement and profiling to identify actual bottlenecks before recommending targeted optimizations. Follow the golden rule: measure first, optimize second.

**Analysis Target**: $ARGUMENTS

## Interface

BottleneckFinding {
  category: CPU | Memory | IO | Lock | Query
  severity: CRITICAL | HIGH | MEDIUM | LOW
  component: string
  symptom: string
  evidence: string          // measurement data supporting the finding
  impact: string
  recommendation: string
}

ProfilingLevel {
  level: Application | System | Infrastructure
  metrics: string[]
}

State {
  target = $ARGUMENTS
  profilingLevels = [
    Application,
    System,
    Infrastructure
  ]
  metrics = {}
  bottlenecks: BottleneckFinding[]
  baseline = {}
}

## Constraints

**Always:**
- Establish baseline metrics before any optimization recommendation.
- Every recommendation must cite measurement evidence.
- Use percentiles (p50, p95, p99) for latency — never averages alone.
- Profile at the right level to find the actual bottleneck.
- Apply Amdahl's Law: focus on biggest contributors first.

**Never:**
- Recommend optimization without measurement evidence.
- Profile only in development — production-like environments required.
- Ignore tail latencies (p99, p999).
- Optimize non-bottleneck code prematurely.
- Cache without defining an invalidation strategy.

## Reference Materials

- reference/profiling-tools.md — Tools by language and platform (Node.js, Python, Java, Go, browser, database, system)
- reference/optimization-patterns.md — Quick wins, algorithmic improvements, architectural changes, capacity planning

## Workflow

### 1. Gather Context

Understand the performance concern: what symptom is observed?
Establish baseline metrics before any changes.

Core methodology — follow this order:
1. Measure — establish baseline metrics
2. Identify — find the actual bottleneck
3. Hypothesize — form a theory about the cause
4. Fix — implement targeted optimization
5. Validate — measure again to confirm improvement
6. Document — record findings and decisions

### 2. Profile System

Profile at appropriate levels:

Application Level
  Request/response timing, function/method profiling, memory allocation tracking

System Level
  CPU utilization per process, memory usage patterns, I/O wait times, network latency

Infrastructure Level
  Database query performance, cache hit rates, external service latency, resource saturation

Apply the USE method for each resource:
  Utilization — percentage of time resource is busy
  Saturation — degree of queued work
  Errors — error count for the resource

Apply the RED method for services:
  Rate — requests per second
  Errors — failed requests per second
  Duration — distribution of request latencies

### 3. Identify Bottlenecks

Classify bottleneck type:

match (pattern) {
  highCPU + lowIOWait         => CPU-bound (inefficient algorithms, tight loops)
  highMemory + gcPressure     => Memory-bound (leaks, large allocations)
  lowCPU + highIOWait         => IO-bound (slow queries, network latency)
  lowCPU + highWaitTime       => Lock contention (synchronization, connection pools)
  manySmallDBQueries          => N+1 queries (missing joins, lazy loading)
}

Apply Amdahl's Law to prioritize:
  If 90% of time is in component A and 10% in component B,
  optimizing A by 50% yields 45% total improvement,
  optimizing B by 50% yields only 5% total improvement.

### 4. Recommend Optimizations

Read reference/optimization-patterns.md for detailed patterns.

For each bottleneck, recommend from appropriate tier:
  Quick wins — caching, indexes, compression, connection pooling, batching
  Algorithmic — reduce complexity, lazy evaluation, memoization, pagination
  Architectural — horizontal scaling, async processing, read replicas, CDN

### 5. Report Findings

Structure output:
1. Summary — performance concern, methodology applied
2. Baseline metrics — measured before analysis
3. Bottleneck findings — sorted by severity with evidence
4. Recommendations — prioritized by impact, with expected improvement
5. Validation plan — how to measure improvement after changes

© Rudolf S. · MIT · rsmdt/the-startup

Similar skills

All skills for Backend and APIs →

performance-analysis by other authors comes first.

performance-analysis ruvnet performance-analysis detects bottlenecks in Claude Flow swarms, profiles agent operations, and generates reports with actionable optimization recommendations. CX Codex +1 1,200installs performance-analysis autohandai performance-analysis guides coding agents to measure latency or memory usage before editing code. Pinpoints performance bottlenecks with reproducible numbers. CX Codex +1 ★ 219repo stars performance-auditor qdhenry performance-auditor — a subagent that hunts bottlenecks: algorithm cost, N+1 queries, bundle size, wasted re-renders. You get a prioritized report. CX Codex ★ 1,357repo stars investigating-performance osmontero investigating-performance stops coding agents from guessing at performance bottlenecks by enforcing strict baselines, target metrics, and dimensioned profiling before touching code. CX Codex +1 146installs performance-engineer VoltAgent performance-engineer — a subagent for diagnosing slow requests, critical paths, and rendering regressions. Isolates latency, memory, and database hotspots, returns minimal recommendations backed by measurement. CX Codex ★ 6,505repo stars performance-optimization akillness performance-optimization turns profiler traces, load tests, and query plans into a targeted tuning brief. Pinpoints a single bottleneck and verifies fixes with before-and-after data. CX Codex +1 367installs performance-monitor VoltAgent performance-monitor triages build, runtime, and operational metrics, weeds out noise, and pinpoints responsible subsystems before heavy profiling starts. CX Codex ★ 6,505repo stars golang-performance samber golang-performance guides AI coding agents through profiling, memory allocation cuts, and CPU optimization in Go projects using a strict measurement-first cycle. CX Codex +1 44,500installs

From the same set50

The whole set →
build-platform build-platform is a Claude Code subagent that orchestrates delivery platforms with containers, infrastructure as code, and deployment pipelines. It supports reproducible environments and rollback-safe releases. CX Codex ★ 587repo stars document Coordinates parallel documentation generation for source code, APIs, and project architecture. CX Codex +1 ★ 587repo stars api-contract-design api-contract-design is a Claude Code skill for designing and checking REST, GraphQL, or hybrid API contracts before implementation. CX Codex +1 ★ 587repo stars review-robustness review-robustness flags fragile code before merge: abstraction layers nothing needs yet, and shared state handled carelessly in async flows. Useful on PR review and for bugs that surface only under load. CX Codex ★ 587repo stars specify-meta specify-meta is a Claude Code skill that creates specification folders and tracks requirements, solution, and plan stages. It records approvals and decisions for a task. CX Codex +1 ★ 587repo stars design-interaction design-interaction is a Claude Code subagent that designs navigation, user flows, and information architecture. Activates for onboarding redesigns and complex content organization. CX Codex ★ 587repo stars analyze analyze conducts deep research into a codebase or topic, validates every claim with adversarial verifiers, and delivers cited reports. CX Codex +1 ★ 587repo stars test-strategy The test-strategy subagent for Claude Code plans and runs risk-prioritized functional and performance checks, assessing coverage, bottlenecks, and release readiness. CX Codex ★ 587repo stars

Project sponsors

Companies that keep this analytics open