performance-analysis

The performance-analysis skill provides a rigorous framework for software performance engineering, designed for developers and architects who prioritize data-driven optimizations over guesswork. This skill enforces the 'measure first, optimize second' golden rule, ensuring that all performance improvements are rooted in verified baseline metrics rather than premature intuition. It acts as a diagnostic assistant to help identify performance regressions, scaling limitations, and resource contention in complex production-like environments.

• Employs the USE (Utilization, Saturation, Errors) and RED (Rate, Errors, Duration) methods for systematic resource and service monitoring.

• Performs multi-level profiling across Application, System, and Infrastructure tiers to isolate bottlenecks accurately.

• Analyzes performance data using latency percentiles (p50, p95, p99, p999) to detect tail latency issues often hidden by simple averages.

• Applies Amdahl's Law to prioritize optimization efforts, focusing on the most significant contributors to total execution time.

• Generates actionable bottleneck findings including category (CPU, Memory, IO, Lock, Query), severity classification, and supporting evidence.

• Recommends targeted optimization patterns ranging from architectural shifts like horizontal scaling and read replicas to granular improvements like caching invalidation strategies and algorithmic complexity reduction.

• Ideal for diagnosing slow request latency, high memory consumption, garbage collection pressure, and inefficient database query execution.

• Requires production-like telemetry and baseline data to function; avoids non-evidence-based optimization recommendations.

• Integrates with reference documentation for platform-specific profiling tools for languages including Node.js, Python, Java, Go, and database systems.

• Outputs a structured report containing a performance summary, baseline comparison, prioritized bottleneck list, and a post-change validation plan.

• Adheres to strict constraints: avoids caching without invalidation strategies and prohibits optimization of non-bottleneck code.