spurpower-performance-investigation

Measure baseline execution time and capture high-frequency profiles to identify compute or IO bottlenecks.

2|Updated Apr 15, 2026
One-click install
npx skills add https://github.com/getspur/spur --skill spurpower-performance-investigation
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: spurpower-performance-investigation
Source: https://github.com/getspur/spur/tree/main/.claude/skills/spurpower-performance-investigation
Command: npx skills add https://github.com/getspur/spur --skill spurpower-performance-investigation

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill addresses the common pitfall of guessing where software bottlenecks exist by enforcing a rigorous, data-driven methodology to measure, localize, and quantify performance issues before applying fixes.

Core Features & Use Cases

  • Measurement-First Workflow: Mandates baseline timing using system tools to ensure all optimizations are validated against real-world wall-clock improvements.
  • Profiling & Quantification: Provides clear guidance on using tools like samply and perf to distinguish between on-CPU compute bottlenecks and off-CPU wait times.
  • Use Case: When a CLI tool experiences latency, use this skill to generate a flamegraph, identify if the delay is caused by subprocess churn or inefficient compute, and verify the impact of a targeted code change.

Quick Start

Use the spurpower-performance-investigation skill to profile the current binary and identify the primary bottleneck using the recommended measurement loop.

Frequently Asked Questions about spurpower-performance-investigation

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

FAQPage Schema
How do I identify compute or IO bottlenecks causing latency in a Rust CLI tool?

To identify compute or IO bottlenecks causing latency in a Rust CLI tool, capture high-frequency profiles using system-level tools like samply or perf to generate accurate call stacks and inclusive timing data for precise localization.

What is the best way to measure baseline execution time before optimizing code?

Measuring baseline execution time requires establishing a rigorous measurement-first workflow using system tools to capture wall-clock timing, ensuring all subsequent code optimizations are validated against real-world performance improvements.

How does profiling distinguish between on-CPU compute and off-CPU wait times?

Profiling distinguishes on-CPU compute from off-CPU wait times by capturing high-frequency call stacks with tools like samply and perf, quantifying whether latency stems from active computation or IO-bound subprocess wait delays.

Do I need system-level profiling tools to generate a flamegraph for resource usage analysis?

Yes, generating a flamegraph for resource usage analysis requires system-level profiling tools like samply or perf to capture the accurate call stacks and inclusive timing data needed to visualize subprocess churn or inefficient compute.

Why does guessing software bottlenecks often lead to ineffective optimization?

Guessing software bottlenecks leads to ineffective optimization because it bypasses data-driven measurement, whereas a rigorous profiling loop quantifies baseline execution time and validates targeted code changes against real wall-clock improvements.

How do I verify the impact of a targeted code change on CLI latency?

To verify the impact of a targeted code change on CLI latency, measure the baseline execution time and compare it against post-optimization wall-clock timings using a rigorous measurement-first performance investigation loop.