performance-engineering

Profile and optimize performance bottlenecks in Rust, C/C++, and Python applications.

Updated Jun 4, 2025
One-click install
npx skills add https://github.com/wizardengineer/dotfiles --skill performance-engineering-wizardengineer
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: performance-engineering
Source: https://github.com/wizardengineer/dotfiles/tree/main/dot_claude/skills/performance-engineering
Command: npx skills add https://github.com/wizardengineer/dotfiles --skill performance-engineering-wizardengineer

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires perf, flamegraph.pl, stackcollapse-perf.pl, heaptrack, valgrind, massif, massif-visualizer, leaks, strace, dtruss, fs_usage, py-spy, samply, speedscope, hotspot, scalene, hyperfine, cg_annotate, ms_print, and includes scripts (resource) and references (resource) components.

What problem does it solve?

Performance bottlenecks across Rust, C/C++, and Python codebases often go unseen until they impact users. This Skill provides structured guidance for profiling, analyzing, and rectifying slow paths, memory issues, and inefficient build times.

Core Features & Use Cases

  • Comprehensive profiling: CPU and memory profiling across languages to locate hot paths.
  • Cross-language tooling: Flamegraphs, perf, valgrind/heaptrack, and language-specific profilers to validate improvements.
  • Use Case: When a Rust service shows latency spikes under load, use this Skill to profile, identify hotspots, and validate optimizations.

Quick Start

Use the performance-engineering skill to run a baseline profiling session, then compare results after changes by invoking the included scripts.

Frequently Asked Questions about performance-engineering

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

FAQPage Schema
How do I profile and find performance bottlenecks in a Python application?

Profile Python applications using py-spy and scalene to collect CPU data, generate flamegraphs, and identify hot paths. This Skill structures the profiling session to locate slow paths and memory issues across your codebase efficiently.

Can I use perf and flamegraphs to optimize a Rust service with latency spikes?

Yes, you can use perf and flamegraph scripts to profile Rust services experiencing latency spikes under load. The Skill guides you through collecting CPU data, generating flamegraphs, and validating optimizations to rectify identified hotspots.

What's the best way to analyze memory leaks in C/C++ codebases?

Analyze C/C++ memory leaks using heaptrack, valgrind, and massif to collect memory profiling data. The Skill provides structured guidance to locate memory issues, generate actionable reports with massif-visualizer, and rectify inefficient allocation paths.

Does this profiling workflow support both Linux and macOS environments?

Yes, the profiling workflow supports both Linux and macOS environments. It utilizes cross-platform tooling such as perf and dtruss, along with language-specific profilers, to ensure you can benchmark and debug applications across different operating systems.

How do I benchmark and compare performance after optimizing code?

Benchmark and compare performance using hyperfine to measure execution times before and after code changes. The Skill enables you to run a baseline profiling session, apply optimizations, and then validate improvements by comparing the updated results against the baseline.