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
/plugin marketplace add rsmdt/the-startup
/plugin install team@the-startupWhat 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-startupThis installs the whole team plugin with all its skills
2Skills CLI (Vercel)
npx skills add rsmdt/the-startup --skill performance-analysis -a claude-code3Manually: put the files in place
~/.claude/skills/performance-analysis/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/performance-analysis/
1Skills CLI (Vercel)
npx skills add rsmdt/the-startup --skill performance-analysis -a codex2Manually: put the files in place
.agents/skills/performance-analysis/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add rsmdt/the-startup --skill performance-analysis -a cursor2Manually: put the files in place
.cursor/skills/performance-analysis/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install rsmdt/the-startup plugins/team/skills/quality/performance-analysis2Manually: put the files in place
.github/skills/performance-analysis/SKILL.md1Skills CLI (Vercel)
npx skills add rsmdt/the-startup --skill performance-analysis -a gemini-cli2Platform CLI
gemini skills install https://github.com/rsmdt/the-startup --path plugins/team/skills/quality/performance-analysisManually: put the files in place
.devin/skills/performance-analysis/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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.