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.