Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
donchitos avatar

Perf Profile

  • 235 installs
  • 23.6k repo stars
  • Updated May 21, 2026
  • donchitos/claude-code-game-studios

perf-profile is an agent skill that profiles game code against performance budgets and ranks optimization fixes.

About

perf-profile is a structured performance profiling workflow for solo and indie game studios using Claude Code with a dedicated performance-analyst agent. You invoke it with a system name to focus on one subsystem or with full for a comprehensive pass across CPU, memory, and rendering surfaces. The skill first aligns work to documented budgets such as 60 FPS frame time, per-system memory caps, load-time targets, and draw-call limits, then systematically hunts bottlenecks in update loops, allocations, asset footprints, and render paths. It is meant for builders who already have runnable code and need prioritized optimization guidance instead of ad-hoc guessing. Bash, Read, Glob, and Grep access let the agent inspect the real codebase rather than theorize. Use it when performance regressions block milestones, when you are approaching a demo or store submission, or when you need a repeatable audit trail before cutting scope or rewriting hot paths.

  • Scopes profiling to one named system or a full cross-system pass via the argument hint.
  • Loads FPS, memory, load-time, draw-call, and multiplayer bandwidth budgets from design docs or CLAUDE.md.
  • Targets hot-path CPU patterns: per-frame update loops, allocations, physics queries, and entity searches.
  • Covers memory footprint, pooling vs instantiate-destroy, leaks, and cache eviction behavior.
  • Adds rendering-oriented checks when applicable: draw calls and overdraw from overlapping geometry.

Perf Profile by the numbers

  • 235 all-time installs (skills.sh)
  • Ranked #86 of 247 Game Development skills by installs in the Skillselion catalog
  • Security screen: LOW risk (skills.sh audit)
  • Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/donchitos/claude-code-game-studios --skill perf-profile

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs235
repo stars23.6k
Security audit3 / 3 scanners passed
Last updatedMay 21, 2026
Repositorydonchitos/claude-code-game-studios

What it does

Run a structured game performance profile against FPS, memory, and rendering budgets before you ship or tune a live build.

Who is it for?

Best when you have an existing codebase and document frame and memory budgets in CLAUDE.md or design docs.

Skip if: Greenfield idea exploration with no runnable game loop, or teams that only need generic web Lighthouse audits.

When should I use this skill?

You need structured profiling with bottleneck identification, budget comparison, and prioritized optimization recommendations for a game codebase.

What you get

You get a scoped bottleneck inventory and prioritized optimization recommendations aligned to your documented FPS, memory, and rendering limits.

  • Scoped profiling report with bottleneck list and priority-ranked optimization recommendations
  • Measurements interpreted against stated performance budgets

By the numbers

  • Supports scoped (system name) or full cross-system profiling modes via the argument hint.

Files

SKILL.mdMarkdownGitHub ↗

Phase 1: Determine Scope

Read the argument:

  • System name → focus profiling on that specific system
  • full → run a comprehensive profile across all systems

---

Phase 2: Load Performance Budgets

Check for existing performance targets in design docs or CLAUDE.md:

  • Target FPS (e.g., 60fps = 16.67ms frame budget)
  • Memory budget (total and per-system)
  • Load time targets
  • Draw call budgets
  • Network bandwidth limits (if multiplayer)

---

Phase 3: Analyze Codebase

CPU Profiling Targets:

  • _process() / Update() / Tick() functions — list all and estimate cost
  • Nested loops over large collections
  • String operations in hot paths
  • Allocation patterns in per-frame code
  • Unoptimized search/sort over game entities
  • Expensive physics queries (raycasts, overlaps) every frame

Memory Profiling Targets:

  • Large data structures and their growth patterns
  • Texture/asset memory footprint estimates
  • Object pool vs instantiate/destroy patterns
  • Leaked references (objects that should be freed but aren't)
  • Cache sizes and eviction policies

Rendering Targets (if applicable):

  • Draw call estimates
  • Overdraw from overlapping transparent objects
  • Shader complexity
  • Unoptimized particle systems
  • Missing LODs or occlusion culling

I/O Targets:

  • Save/load performance
  • Asset loading patterns (sync vs async)
  • Network message frequency and size

---

Phase 4: Generate Profiling Report

## Performance Profile: [System or Full]
Generated: [Date]

### Performance Budgets
| Metric | Budget | Estimated Current | Status |
|--------|--------|-------------------|--------|
| Frame time | [16.67ms] | [estimate] | [OK/WARNING/OVER] |
| Memory | [target] | [estimate] | [OK/WARNING/OVER] |
| Load time | [target] | [estimate] | [OK/WARNING/OVER] |
| Draw calls | [target] | [estimate] | [OK/WARNING/OVER] |

### Hotspots Identified
| # | Location | Issue | Estimated Impact | Fix Effort |
|---|----------|-------|------------------|------------|

### Optimization Recommendations (Priority Order)
1. **[Title]** — [Description]
   - Location: [file:line]
   - Expected gain: [estimate]
   - Risk: [Low/Med/High]
   - Approach: [How to implement]

### Quick Wins (< 1 hour each)
- [Simple optimization 1]

### Requires Investigation
- [Area that needs actual runtime profiling to confirm impact]

Output the report with a summary: top 3 hotspots, estimated headroom vs budget, and recommended next action.

---

Phase 5: Scope and Timeline Decision

Activate this phase only if any hotspot has Fix Effort rated M or L.

Present significant-effort items and ask the user to choose for each:

  • A) Implement the optimization (proceed with fix now or schedule it)
  • B) Reduce feature scope (run /scope-check [feature] to analyze trade-offs)
  • C) Accept the performance hit and defer to Polish phase (log as known issue)
  • D) Escalate to technical-director for an architectural decision (run /architecture-decision)

If multiple items are deferred to Polish (choice C), record them under ### Deferred to Polish.

This skill is read-only — no files are written. Verdict: COMPLETE — performance profile generated.

---

Phase 6: Next Steps

  • If bottlenecks require architectural change: run /architecture-decision.
  • If scope reduction is needed: run /scope-check [feature].
  • To schedule optimizations: run /sprint-plan update.

Rules

  • Never optimize without measuring first — gut feelings about performance are unreliable
  • Recommendations must include estimated impact — "make it faster" is not actionable
  • Profile on target hardware, not just development machines
  • Static analysis (this skill) identifies candidates; runtime profiling confirms

Related skills

How it compares

Use instead of one-off “make it faster” chat threads when you need game-specific CPU, memory, and draw-call profiling tied to budgets.

FAQ

Who is perf-profile for?

and small-studio game developers using Claude Code who need analyst-style profiling across systems before ship or during live tuning.

When should I use perf-profile?

In Ship when validating perf before release; in Operate when diagnosing regressions after patches; in Build when a subsystem’s Update/Tick cost balloons mid-sprint.

Is perf-profile safe to install?

It requests Read, Glob, Grep, and Bash to inspect your repo—review the Security Audits panel on this page and restrict Bash if your environment requires it.

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.