stick-crisis-performance-optimizer

Scan Unity codebases for expensive API calls and debug logging.

Updated May 10, 2026
One-click install
npx skills add https://github.com/VMRam95/vmram-skills --skill stick-crisis-performance-optimizer
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: stick-crisis-performance-optimizer
Source: https://github.com/VMRam95/vmram-skills/tree/main/skills/stick-crisis-performance-optimizer
Command: npx skills add https://github.com/VMRam95/vmram-skills --skill stick-crisis-performance-optimizer

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires rg, dotnet, and includes scripts (resource) and references (resource) components.

What problem does it solve?

This skill addresses performance degradation in Unity projects by providing a structured, repeatable workflow to identify and eliminate CPU bottlenecks, excessive garbage collection, and inefficient runtime operations.

Core Features & Use Cases

  • Automated Inventory: Scans the codebase for expensive runtime API calls, debug log spam, and hot-path method definitions.
  • Performance Profiling: Provides a standardized workflow for baseline creation and comparative analysis of frame-time and GC pressure.
  • Use Case: Use this skill when your game experiences frame drops or stuttering to automatically generate a report of high-impact hotspots and apply targeted optimizations to your Unity scripts.

Quick Start

Run the stick-crisis-performance-optimizer skill to scan your project for hot paths and generate a performance inventory report.

Frequently Asked Questions about stick-crisis-performance-optimizer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I optimize Unity performance by finding expensive runtime API calls?▼

To optimize Unity performance, you can scan your C# codebase to inventory expensive runtime API calls and debug log spam. This process identifies hot paths in your update loops to target frame-time bottlenecks and reduce garbage collection pressure.

Why does my Unity game stutter and how can I reduce garbage collection pressure?▼

Unity game stutter often stems from excessive garbage collection pressure and expensive runtime operations in update loops. Identifying and refactoring these hot-path methods eliminates CPU bottlenecks, ensuring stable frame rates and smoother gameplay.

What's the best way to profile Unity frame-time bottlenecks in C# scripts?▼

The best way to profile Unity frame-time bottlenecks is using a structured workflow that establishes a baseline and performs comparative analysis. Scanning scripts for inefficient update loop patterns generates a report of high-impact hotspots for targeted optimization.

Do I need ripgrep and dotnet to analyze Unity gameplay hot paths?▼

Yes, you need ripgrep (rg) or grep for code analysis to find hot paths, and a dotnet environment for project builds. These dependencies are required to scan the codebase and validate performance improvements in your Unity scripts.

Can I automate identifying inefficient update loop patterns in Unity projects?▼

Yes, you can automate identifying inefficient update loop patterns by running a codebase scan. This generates a performance inventory report that highlights debug log spam and runtime API hotspots, allowing you to apply targeted optimizations directly.

Are there limitations to refactoring Unity scripts for frame-time optimization?▼

Limitations include relying on static code analysis via ripgrep to find bottlenecks, which may miss dynamic runtime profiling context. Optimization is focused on gameplay hot paths and update loops, requiring a dotnet environment to verify reduced garbage collection pressure.