Skip to content
Skills Library
Programming · Analysis

performance-analysis

/performance-analysis

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.

Author
rsmdt ↗
Repository
the-startup ↗
Licence
MIT
Last repository change
11.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 11.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

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.

Original author 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.

How it works

  1. Persona
  2. Interface
  3. Constraints
  4. Reference Materials
  5. Workflow
Original SKILL.md headings · 131 lines, 559 words
SKILL.md preview
---
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

Files in this package (3)
  • SKILL.md 4 KB
  • reference/optimization-patterns.md 2 KB
  • reference/profiling-tools.md 10 KB

Versions

RepositoryScoreLicence
This page · rsmdt/the-startup90MIT
frankxai/claude-skills-library100MIT
dreamlab-ai/agentbox100AGPL-3.0
autohandai/code-cli100Apache-2.0
0xsarwagya/ontoly100AGPL-3.0

Database snapshot: 13.11.2026 · package version 83f8e0039fa8 (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

  • 100python-performance
    Profiles Python code for performance bottlenecks and memory issues. Use when Python code is slow or when profiling for optimization before a release.
  • 88dev-loop-performance-profiler
    Use when the user asks about performance profiling, application performance, profiling tools, performance optimization, bottleneck analysis, or performance testing. Do NOT use for: debugging bugs (dev-loop-debugging-strategy), or code review (dev-loop-code-review).
  • 100performance-observability
    Use to diagnose performance with baselines, profiling, system measurements, and safe observability practices, and to verify changes against evidence.
  • 100performance-optimization
    Optimizes application performance across frontend, backend, queries, and databases. Use when performance requirements exist, when you suspect performance regressions, when Core Web Vitals or load times need improvement, when N+1 query patterns need fixing, or when profiling reveals bottlenecks.
  • 100godot-performance-optimization
    Expert blueprint for performance profiling and optimization (frame drops, memory leaks, draw calls) using Godot Profiler, object pooling, visibility culling, and bottleneck identification. Use when diagnosing lag, optimizing for target FPS, or reducing memory usage. Keywords…
  • 90performance-optimization
    Measure-first approach for Core Web Vitals targets, profiling workflows, bundle analysis, and anti-pattern detection. Use when performance requirements exist or you suspect regressions.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.