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.
- Author
- tansuasici ↗
- Repository
- claude-code-kit ↗
- Licence
- MIT
- Last repository change
- 21.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 21.10.2026, without references to retired models or APIs.
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
- Core Rule
- When to Use
- Default Behavior
- Process
- Output Format
- Notes
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
| Repository | Score | Licence |
|---|---|---|
| This page · tansuasici/claude-code-kit | 100 | MIT |
| andreibesleaga/gabbe | 100 | CC-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".