Skip to content
Skills Library
Programming · Review & audit

performance-audit

/performance-audit

Identify performance bottlenecks — rendering, startup, memory, and I/O — across any stack. Use when the app is slow, before perf-sensitive releases, or when the user mentions latency, jank, or memory growth.

Licence
MIT
Last repository change
21.10.2026

Assessment and security

100/ 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.
Content35 / 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
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 21.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

Identify performance bottlenecks — rendering, startup, memory, and I/O — across any stack. Use when the app is slow, before perf-sensitive releases, or when the user mentions latency, jank, or memory growth.

Original author description

Identify performance bottlenecks — rendering, startup, memory, and I/O — across any stack. Use when the app is slow, before perf-sensitive releases, or when the user mentions latency, jank, or memory growth.

How it works

  1. Core Rule
  2. When to Use
  3. Default Behavior
  4. Process
  5. Output Format
  6. Notes
Original SKILL.md headings · 131 lines, 674 words
SKILL.md preview
---
name: performance-audit
description: Identify performance bottlenecks — rendering, startup, memory, and I/O — across any stack. Use when the app is slow, before perf-sensitive releases, or when the user mentions latency, jank, or memory growth.
user-invocable: true
allowed-tools: Read, Grep, Glob
---

# Performance Audit

## Core Rule

Report measurable bottlenecks with reproduction steps, not theoretical optimizations. Validate large-input assumptions before recommending complexity changes.

## When to Use

Invoke with `/performance-audit` when:

- Users report slowness or performance degradation
- Before a production launch or scale-up
- After adding significant new features
- During optimization sprints or performance budgeting

## Default Behavior

When the user asks to audit, scan, review, or "give me a report" for performance / bottlenecks, produce the full performance-audit report automatically using the Process and Output Format sections below. Do not require the user to specify fields.

Only modify files when the user explicitly requests implement / fix / apply / refactor. By default, this skill is **report-only**.

## Process

### Phase 1: Inventory (first-pass leads)

This pass produces **candidates**, not findings. Treat counts as leads for deeper inspection in later phases. Do not report Phase 1 raw output as the final result.

Read project config files to determine the tech stack:

- **Frontend**: React, Vue, Angular, Svelte, Flutter, native mobile
- **Backend**: Node.js, Python, Go, Rust, Java, .NET
- **Database**: SQL, NoSQL, ORM in use
- **Infrastructure**: Caching layers, CDN, message queues

### Phase 2: Startup & Load Performance

Analyze initial load and startup paths:

- **Entry points**: Main module, bootstrap files, initialization sequences
- **Lazy loading**: Are heavy modules loaded upfront unnecessarily?
- **Import chains**: Deep import trees that block startup
- **Initialization**: Synchronous blocking during startup (DB connections, config loading)
- **Bundle size** (web): Large dependencies, missing tree-shaking, unoptimized assets

### Phase 3: Runtime Bottlenecks

Scan for common runtime performance issues:

**CPU-bound**
- O(n²) or worse algorithms in hot paths
- Unnecessary re-computation (missing memoization/caching)
- Synchronous heavy computation on the main/UI thread
- Regex backtracking on user input

**Memory**
- Memory leaks: event listeners not cleaned up, growing caches without eviction
- Large object retention: holding references to data no longer needed
- Unbounded collections: arrays/maps that grow without limits
- String concatenation in loops (in languages where strings are immutable)

**I/O-bound**
- N+1 query patterns (loop with DB/API call inside)
- Sequential API calls that could be parallel
- Missing database indexes on filtered/sorted columns
- Unbatched writes (inserting rows one at a time)
- Missing connection pooling

**Rendering (UI applications)**
- Unnecessary re-renders (React: missing memo/useMemo/useCallback, Vue: reactive over-tracking)
- Layout thrashing (reading layout properties between DOM writes)
- Large lists without virtualization
- Heavy computation in render paths
- Unoptimized images/assets (missing lazy loading, wrong formats, no responsive sizes)
- Animations on non-composited properties (layout-triggering CSS)

### Phase 4: Caching & Data Flow

Check caching strategy:

- Missing caching for expensive computations or API responses
- Cache invalidation issues (stale data served)
- Over-caching (caching cheap operations, wasting memory)
- Missing HTTP caching headers for static assets
- Database query result caching

### Phase 5: Concurrency & Async

Review async patterns:

- Unparallelized independent async operations (sequential await in loop)
- Missing backpressure handling (unbounded queues, no rate limiting)
- Thread pool exhaustion (blocking calls in async context)
- Deadlock potential in concurrent code

## Output Format

```markdown
# Performance Audit Report

## Executive Summary
[Overall performance health, top 3 critical findings]

## Critical Bottlenecks
| # | Category | Location | Issue | Impact | Fix |
|---|----------|----------|-------|--------|-----|
| 1 | I/O      | file:line | N+1 query in user list | O(n) DB calls per request | Batch query with IN clause |

## Optimization Opportunities
| # | Category | Location | Issue | Estimated Gain | Fix |
|---|----------|----------|-------|----------------|-----|

## Metrics
- Hot paths analyzed: N
- Critical bottlenecks: N
- Optimization opportunities: N
- Estimated impact: low/medium/high improvement potential

## Quick Wins
[List of easy fixes with high impact]

## Requires Investigation
[Issues that need profiling data to confirm]
```

## Notes

- This audit identifies likely bottlenecks through static analysis — profiling data confirms impact
- Focus on hot paths (request handlers, frequently called functions, render loops)
- Don't recommend premature optimization — only flag issues in paths that matter

Versions

RepositoryScoreLicence
This page · tansuasici/claude-code-kit100MIT
andreibesleaga/gabbe100CC-BY-4.0

Database snapshot: 13.11.2026 · package version bb133fbe62b3 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 1 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 95performance-review
    [Debugging] Use when a workflow step or the user asks for performance bottleneck analysis and validated fixes: queries, memory, network, rendering and concurrency.
  • 95performance-review
    [Debugging] Use when a workflow step or the user asks for performance bottleneck analysis and validated fixes: queries, memory, network, rendering and concurrency.
  • 100perf-profile
    Identifies performance bottlenecks, measures against budgets, and generates prioritized optimization recommendations. Use when investigating slow performance or when the user mentions performance profiling, bottleneck, or optimization.
  • 100detecting-performance-bottlenecks
    Execute this skill enables AI assistant to detect and resolve performance bottlenecks in applications. it analyzes cpu, memory, i/o, and database performance to identify areas of concern. use this skill when you need to diagnose slow application performance, op... Use when…
  • 100detecting-performance-bottlenecks
    Execute this skill enables AI assistant to detect and resolve performance bottlenecks in applications. it analyzes cpu, memory, i/o, and database performance to identify areas of concern. use this skill when you need to diagnose slow application performance, op... Use when…
  • 100spine-perf
    Find and fix performance bottlenecks — N+1 queries, missing indexes, sync bottlenecks, caching gaps. Use when asked "why is this slow", "performance issue", "optimize this endpoint", or "N+1 queries".

Feedback and reports

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