grey-haven-performance-optimization

Identify and optimize performance bottlenecks across algorithms, databases, frontend, bundles, API caching, and memory management.

29|4|Updated Aug 10, 2025
One-click install
npx skills add https://github.com/greyhaven-ai/claude-code-config --skill grey-haven-performance-optimization
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: grey-haven-performance-optimization
Source: https://github.com/greyhaven-ai/claude-code-config/tree/main/grey-haven-plugins/core/skills/performance-optimization
Command: npx skills add https://github.com/greyhaven-ai/claude-code-config --skill grey-haven-performance-optimization

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and templates (resource) components.

What problem does it solve?

This Skill eliminates the time-consuming manual work of identifying and fixing performance bottlenecks across your entire application stack.

Core Features & Use Cases

  • Comprehensive Analysis: Automatically identify bottlenecks in algorithms, databases, React components, and API responses.
  • Proven Optimizations: Apply production-ready patterns that deliver 85%+ performance improvements.
  • Use Case: Imagine your application is running slow with high CPU usage. Use this Skill to analyze performance issues and implement optimizations that can make your app 100x faster.

Quick Start

Analyze the performance bottlenecks in the provided code snippet and suggest specific optimizations to improve response times.

Frequently Asked Questions about grey-haven-performance-optimization

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

FAQPage Schema
How do I identify performance bottlenecks in my application?

Performance bottlenecks are slowdowns in algorithms, databases, frontend components, API responses, or memory usage that reduce application responsiveness. This Skill automatically analyzes your code across all layers—algorithms, databases, React components, bundles, and caching—to pinpoint exactly where slowdowns originate, then delivers specific optimizations tailored to each bottleneck type.

Can I optimize database queries and API caching together?

Yes. This Skill comprehensively addresses database optimization, API caching strategies, and memory management as interconnected performance levers. It applies production-ready patterns across all three areas simultaneously, recognizing that database inefficiency often compounds with poor caching and memory allocation to create cascading latency.

What does a 100x performance improvement actually involve?

Performance improvements combine multiple optimization techniques: algorithm efficiency gains, database query optimization, frontend rendering optimizations, bundle size reduction, API response caching, and memory leak fixes. This Skill delivers production-ready patterns, templates, and validation checklists that measure improvements with concrete performance metrics rather than guesswork.

How do I validate that performance optimizations actually work?

Validation requires measurable performance metrics before and after optimization. This Skill provides checklists and patterns for diagnosing bottlenecks, implementing fixes, and measuring results—tracking CPU usage, memory consumption, response times, and latency to confirm whether optimizations achieve your SLA targets.

Does this work for production applications experiencing SLA breaches?

Yes. This Skill targets production scenarios directly: slow or unresponsive applications, SLA breaches, high CPU or memory usage, and user-reported performance issues. It delivers production-ready templates and patterns proven to resolve real-world bottlenecks without requiring extensive trial-and-error.

What if I have memory leaks causing high memory usage?

Memory leaks fall within the Skill's scope as part of comprehensive memory management optimization. The Skill identifies memory-related bottlenecks alongside algorithm, database, frontend, and caching issues, then applies specific patterns to diagnose and fix memory leaks as part of the broader performance tuning workflow.