cpu-memory-review

Route Rust CPU and memory findings through cold-vs-hot call-chain decision cases.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/Pandaala/Edgion --skill cpu-memory-review
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: cpu-memory-review
Source: https://github.com/Pandaala/Edgion/tree/main/skills/04-review/cpu-memory
Command: npx skills add https://github.com/Pandaala/Edgion --skill cpu-memory-review

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you quickly separate genuine CPU and memory performance problems from common false positives during code review, by routing each finding to an evidence-backed decision pattern.

Core Features & Use Cases

  • Methodology-first review: trace the call chain and explicitly distinguish cold/config-load phases from hot/request-handling phases to avoid chasing non-triggered behavior.
  • Scenario-based decisioning: use the indexed case files to match a finding (e.g., Arc clone, regex precompile, bounded buffers, admin-path work) against a “confirmed vs false positive vs accepted tradeoff” rule.
  • Rapid triage workflow: start with the general methodology, then pivot into the specific case by name or search for it in the case directory.

Quick Start

Use the cpu-memory-review Skill to evaluate a new CPU/memory finding by first following the general methodology decision flow, then matching the finding to the best matching case file under cases/.

Frequently Asked Questions about cpu-memory-review

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

FAQPage Schema
How do I identify false positives in Rust CPU and memory performance audits?

Rust performance audits can identify false positives by tracing the call chain to distinguish cold config-load phases from hot request-handling phases, verifying triggering conditions before treating allocations or cloning as real overhead.

When do I need to distinguish hot path vs cold path for code review?

Distinguishing hot path vs cold path is needed when reviewing CPU and memory findings to avoid chasing non-triggered behavior, ensuring reported overhead in allocations, regex compilation, or buffering actually executes during request handling.

How do I evaluate lock contention and Arc clone findings in a Rust codebase?

Evaluate Arc clone and lock contention findings by matching them against scenario-specific decision cases that classify the overhead as a confirmed problem, false positive, or accepted tradeoff based on controller-plane versus data-plane execution paths.

What is the best way to triage regex compilation and memory allocation overhead during code review?

The best way to triage regex compilation and memory allocation overhead is following a methodology-first decision flow that traces the call chain, confirms the triggering mechanism, and matches the finding to indexed case files for verdict.

Can I use this methodology to review metrics and serialization patterns on controller-plane paths?

Yes, the review methodology applies to metrics and serialization patterns across both controller-plane and data-plane paths, verifying whether the underlying mechanism triggers actual CPU or memory overhead before recommending code changes.

Why does my code audit flag bounded buffers and cloning as performance issues when they are not triggered?

Code audits often flag bounded buffers and cloning as performance issues because static analysis cannot determine execution frequency; routing findings through cold-vs-hot call-chain methodology confirms whether the triggering condition actually occurs.