New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Performance Analysis

by rsmdt in rsmdt/the-startup

Measurement approaches, profiling patterns, bottleneck identification, and optimization guidance.

MITAuto-check passed

Install Performance Analysis

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

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install rsmdt/the-startup performance-analysis --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/rsmdt/the-startup.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/team/skills/quality/performance-analysis .claude/skills/performance-analysis && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
performance-analysis
GitHub stars
551
Token cost
~1.1k tokens
SKILL.md length
477 words
Files
3
Skills in repo
27
Repo updated
First seen
Licence
MIT

At a glance

Measurement approaches, profiling patterns, bottleneck identification, and optimization guidance.

  • Works in 5 steps: Gather Context → Profile System → Identify Bottlenecks → …
  • Diagnosing performance issues
  • SKILL.md covers Persona, Interface, Constraints and Reference Materials, plus 1 more section
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Performance Analysis is an agent skill from rsmdt/the-startup. 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.

Its SKILL.md is about 1.1k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files (for example `reference/optimization-patterns.md` and `reference/profiling-tools.md`).

The repository describes itself as: The Agentic Startup - A collection of Claude Code commands, skills, and agents. The licence is MIT.

When your agent uses it

  • Diagnosing performance issues
  • Establishing baselines
  • Identifying bottlenecks
  • Planning for scale

Example prompts

  • “/performance-analysis”

Requirements

  • Node.js

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Gather Context
  2. Profile System
  3. Identify Bottlenecks
  4. Recommend Optimizations
  5. Report Findings

What it can do on your machine

Read from SKILL.md and the folder at commit 88d447c. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Performance Analysis loads about 1.1k tokens when it runs. Until then it costs about 66 tokens; SKILL.md has 477 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~66
When it runs · the whole SKILL.md, loaded when a task matches
~1.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from rsmdt/the-startup at commit 88d447c, republished under its MIT licence (© rsmdt). 477 words, ~1,119 tokens.

Download SKILL.mdSave it as .claude/skills/performance-analysis/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
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

Show full SKILL.md (157 more words)Show less
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

© rsmdt, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files in plugins/team/skills/quality/performance-analysis of rsmdt/the-startup.

  • SKILL.md
  • reference/optimization-patterns.md
  • reference/profiling-tools.md

Open the folder on GitHubat commit 88d447c

Compare with similar skills

Performance Analysis next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Performance Analysis compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Performance Analysis this skillrsmdt/the-startup551—~1.1kAutomated safety check: PassMIT
Profileccusage/ccusage19k—~430Automated safety check: PassCustom licence
Cpu ProfileClickHouse/ClickHouse50k—~1.9kAutomated safety check: NotesApache-2.0
Codex Profilessickn33/agentic-awesome-skills47k1 repos~1.7kAutomated safety check: PassMIT
Profile Query BottleneckJetBrains/youtrackdb437—~6.4kAutomated safety check: WarnApache-2.0
Collectors Snmp Profilesnetdata/netdata81k—~3.1kAutomated safety check: PassGPL-3.0

Similar skills

  • Profile

    ccusage/ccusage

    Profiles ccusage performance. An agent skill from ccusage/ccusage.

    19k GitHub stars~430 tokensUpdated today
    Auto-check passed

  • Cpu Profile

    ClickHouse/ClickHouse

    Profile a ClickHouse query using the sampling query profiler and system.tracelog.

    50k GitHub stars~1.9k tokensUpdated today
    DatabasesAuto-check: notes

  • Codex Profiles

    sickn33/agentic-awesome-skills

    Use codex-profiles to run Codex CLI or Codex Desktop with isolated CODEXHOME profiles for separate accounts, projects, and local state.

    47k GitHub starsUsed in 1 repo~1.7k tokens
    Auto-check passed

  • Profile Query Bottleneck

    JetBrains/youtrackdb

    Official

    Profile and diagnose YouTrackDB SQL/MATCH query bottlenecks.

    437 GitHub stars~6.4k tokensUpdated today
    DevelopmentAuto-check: warnings

  • Collectors Snmp Profiles

    netdata/netdata

    Author or review Netdata SNMP polling profiles, ddsnmp parsing, topology/licensing/BGP rows and profile-format documentation.

    81k GitHub stars~3.1k tokensUpdated today
    Frontend & DesignAuto-check passed

  • Game Performance Profiler

    Donchitos/Claude-Code-Game-Studios

    Finds performance bottlenecks, measures them against frame, draw-call and memory budgets, and ranks the optimization recommendations.

    26k GitHub stars~2.5k tokensUpdated 8 days ago
    Game DevelopmentAuto-check: notes

More from rsmdt/the-startup

All 27 skills in this repo

  • Analyze

    rsmdt/the-startup

    Deep-dive codebase analysis that explains how things actually work — business rules, architecture patterns, auth flows, data models, integrations, and performance hotspots.

    551 GitHub stars~1.9k tokensUpdated 2 mo ago
    Auto-check passed

  • Implement

    rsmdt/the-startup

    Implementation entry point. An agent skill from rsmdt/the-startup.

    551 GitHub stars~1.3k tokensUpdated 2 mo ago
    Auto-check passed

  • Implement Factory

    rsmdt/the-startup

    Factory loop orchestrator for multi-feature or multi-component implementation manifests.

    551 GitHub stars~3.2k tokensUpdated 2 mo ago
    Auto-check passed

  • Agentic Patterns

    rsmdt/the-startup

    Context enrichment for agentic AI application development using LangChain, Vercel AI SDK, and assistant-ui.

    551 GitHub stars~501 tokensUpdated 2 mo ago
    Auto-check passed

  • API Contract Design

    rsmdt/the-startup

    REST and GraphQL API design patterns, OpenAPI/Swagger specifications, versioning strategies, and authentication patterns.

    551 GitHub stars~1.1k tokensUpdated 2 mo ago
    Auto-check passed

  • Architecture Selection

    rsmdt/the-startup

    System architecture patterns including monolith, microservices, event-driven, and serverless, with C4 modeling, scalability strategies, and technology selection criteria.

    551 GitHub stars~1.2k tokensUpdated 2 mo ago
    Auto-check passed

Questions about Performance Analysis

What does Performance Analysis do?

Measurement approaches, profiling patterns, bottleneck identification, and optimization guidance. Performance Analysis is an agent skill from rsmdt/the-startup. Measurement approaches, profiling patterns, bottleneck identification, and optimization guidance.

When should I use Performance Analysis?

Performance Analysis fits situations like: diagnosing performance issues; establishing baselines; identifying bottlenecks; planning for scale.

How do I install Performance Analysis in Claude Code?

Run `npx skills add rsmdt/the-startup --skill performance-analysis -a claude-code`. Or copy the skill folder (plugins/team/skills/quality/performance-analysis in rsmdt/the-startup) into .claude/skills/performance-analysis in your project. Claude Code loads it when a task matches its description.

How do I install Performance Analysis in Codex?

Run `npx skills add rsmdt/the-startup --skill performance-analysis -a codex`. Or copy the skill folder (plugins/team/skills/quality/performance-analysis in rsmdt/the-startup) into .agents/skills/performance-analysis in your project. Codex loads it when a task matches its description.

Can I use Performance Analysis in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add rsmdt/the-startup --skill performance-analysis -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/performance-analysis, .gemini/skills/performance-analysis, .github/skills/performance-analysis and .opencode/skills/performance-analysis in your project.

What does Performance Analysis need to run?

SKILL.md names no scripts, command-line tools or credentials: Performance Analysis is instructions for the agent only. Our summary lists: Node.js.

Does Performance Analysis access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Performance Analysis safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Performance Analysis use?

Performance Analysis is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Performance Analysis use?

About 1.1k tokens (SKILL.md is roughly 4.5k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Performance Analysis?

Skills that share tags, products or a category with Performance Analysis: Profile (ccusage/ccusage, 19k stars), Cpu Profile (ClickHouse/ClickHouse, 50k stars), Codex Profiles (sickn33/agentic-awesome-skills, 47k stars) and Profile Query Bottleneck (JetBrains/youtrackdb, 437 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Performance Analysis?

rsmdt (a GitHub user) maintains it in rsmdt/the-startup, which has 551 GitHub stars. The repository holds 27 skills in this directory. The repository was last updated on August 3, 2026.

Source: rsmdt/the-startup on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.