🎯

m10-performance

🎯Skill

from goooice/rust-skills

What it does

Optimizes code performance by identifying bottlenecks, measuring impact, and guiding strategic improvements across algorithm, data structure, and memory efficiency.

📦

Part of

goooice/rust-skills(35 items)

m10-performance

Installation

Add MarketplaceAdd marketplace to Claude Code

/plugin marketplace add ZhangHanDong/rust-skills

Install PluginInstall plugin from marketplace

/plugin install rust-skills@rust-skills

Quick InstallInstall with npx

npx skills add ZhangHanDong/rust-skills

git cloneClone repository

git clone https://github.com/ZhangHanDong/rust-skills.git

📖 Extracted from docs: goooice/rust-skills

Need more details? View full documentation on GitHub →

4Installs

AddedFeb 4, 2026

View on GitHub Back to Skills

Skill Details

SKILL.md

"CRITICAL: Use for performance optimization. Triggers: performance, optimization, benchmark, profiling, flamegraph, criterion, slow, fast, allocation, cache, SIMD, make it faster, 性能优化, 基准测试"

Overview

# Performance Optimization

> Layer 2: Design Choices

Core Question

What's the bottleneck, and is optimization worth it?

Before optimizing:

Have you measured? (Don't guess)
What's the acceptable performance?
Will optimization add complexity?

---

Performance Decision → Implementation

| Goal | Design Choice | Implementation |

|------|---------------|----------------|

| Reduce allocations | Pre-allocate, reuse | with_capacity, object pools |

| Improve cache | Contiguous data | Vec, SmallVec |

| Parallelize | Data parallelism | rayon, threads |

| Avoid copies | Zero-copy | References, Cow |

| Reduce indirection | Inline data | smallvec, arrays |

---

Thinking Prompt

Before optimizing:

Have you measured?

- Profile first → flamegraph, perf

- Benchmark → criterion, cargo bench

- Identify actual hotspots

What's the priority?

- Algorithm (10x-1000x improvement)

- Data structure (2x-10x)

- Allocation (2x-5x)

- Cache (1.5x-3x)

What's the trade-off?

- Complexity vs speed

- Memory vs CPU

- Latency vs throughput

---

Trace Up ↑

To domain constraints (Layer 3):

```

"How fast does this need to be?"

↑ Ask: What's the performance SLA?

↑ Check: domain-* (latency requirements)

↑ Check: Business requirements (acceptable response time)

```

| Question | Trace To | Ask |

|----------|----------|-----|

| Latency requirements | domain-* | What's acceptable response time? |

| Throughput needs | domain-* | How many requests per second? |

| Memory constraints | domain-* | What's the memory budget? |

---

Trace Down ↓

To implementation (Layer 1):

```

"Need to reduce allocations"

↓ m01-ownership: Use references, avoid clone

↓ m02-resource: Pre-allocate with_capacity

"Need to parallelize"

↓ m07-concurrency: Choose rayon or threads

↓ m07-concurrency: Consider async for I/O-bound

"Need cache efficiency"

↓ Data layout: Prefer Vec over HashMap when possible

↓ Access patterns: Sequential over random access

```

---

Quick Reference

| Tool | Purpose |

|------|---------|

| cargo bench | Micro-benchmarks |

| criterion | Statistical benchmarks |

| perf / flamegraph | CPU profiling |

| heaptrack | Allocation tracking |

| valgrind / cachegrind | Cache analysis |

Optimization Priority

```

Algorithm choice (10x - 1000x)
Data structure (2x - 10x)
Allocation reduction (2x - 5x)
Cache optimization (1.5x - 3x)
SIMD/Parallelism (2x - 8x)

```

Common Techniques

| Technique | When | How |

|-----------|------|-----|

| Pre-allocation | Known size | Vec::with_capacity(n) |

| Avoid cloning | Hot paths | Use references or Cow |

| Batch operations | Many small ops | Collect then process |

| SmallVec | Usually small | smallvec::SmallVec<[T; N]> |

| Inline buffers | Fixed-size data | Arrays over Vec |

---

Common Mistakes

| Mistake | Why Wrong | Better |

|---------|-----------|--------|

| Optimize without profiling | Wrong target | Profile first |

| Benchmark in debug mode | Meaningless | Always --release |

| Use LinkedList | Cache unfriendly | Vec or VecDeque |

| Hidden .clone() | Unnecessary allocs | Use references |

| Premature optimization | Wasted effort | Make it work first |

---

Anti-Patterns

| Anti-Pattern | Why Bad | Better |

|--------------|---------|--------|

| Clone to avoid lifetimes | Performance cost | Proper ownership |

| Box everything | Indirection cost | Stack when possible |

| HashMap for small sets | Overhead | Vec with linear search |

| String concat in loop | O(n^2) | String::with_capacity or format! |

---

Related Skills

| When | See |

|------|-----|

| Reducing clones | m01-ownership |

| Concurrency options | m07-concurrency |

| Smart pointer choice | m02-resource |

| Domain requirements | domain-* |

More from this repository10

🎯

m14-mental-model🎯Skill

Applies the M14 mental model framework to enhance decision-making and strategic thinking through structured cognitive analysis.

🎯

m04-zero-cost🎯Skill

Guides developers in choosing zero-cost abstractions by analyzing type system constraints and performance trade-offs in Rust generics and traits.

🎯

meta-cognition-parallel🎯Skill

Performs parallel three-layer meta-cognitive analysis by forking subagents to simultaneously analyze language mechanics, design choices, and domain constraints, then synthesizing results.

🎯

unsafe-checker🎯Skill

Identifies and reviews unsafe Rust code patterns, FFI risks, and potential memory unsafety in Rust projects.

🎯

rust-skill-creator🎯Skill

Dynamically generates Claude skills for Rust crates, standard library modules, and documentation by extracting and processing technical details from specified URLs.

🎯

coding-guidelines🎯Skill

Provides comprehensive Rust coding guidelines covering naming conventions, best practices, error handling, memory management, concurrency, and code style recommendations.

🎯

rust-refactor-helper🎯Skill

Performs safe Rust refactoring by analyzing symbol references, checking conflicts, and applying changes across project files using LSP.

🎯

m03-mutability🎯Skill

Diagnoses and guides resolution of Rust mutability and borrowing conflicts by analyzing ownership, mutation patterns, and thread-safety requirements.

🎯

domain-iot🎯Skill

Enables building robust, efficient IoT applications with offline-first design, power-aware networking, and secure device communication using Rust.

🎯

m05-type-driven🎯Skill

Explores and demonstrates type-driven development techniques in Rust, showcasing advanced type system features and pattern matching strategies.