Performance Engineering Standards
Scannednpx machina-cli add skill hoangnguyen0403/agent-skills-standard/performance-engineering --openclawFiles (1)
SKILL.md
2.5 KB
Performance Engineering Standards
Universal standards for high-performance software development across all frameworks.
Priority: P1 (OPERATIONAL)
Universal standards for building high-performance software across all frameworks and languages.
🚀 Core Principles
- Efficiency by Design: Minimize resource consumption (CPU, Memory, Network) without sacrificing readability.
- Measure First: Never optimize without a baseline. Use profiling tools before and after changes.
- Scalability: Design systems to handle increased load by optimizing time and space complexity.
💾 Resource Management
- Memory Efficiency:
- Avoid memory leaks: explicit cleanup of listeners, observers, and streams.
- Optimize data structures: use the most efficient collection for the use case (e.g.,
Setfor lookups,Listfor iteration). - Lazy Initialization: Initialize expensive objects only when needed.
- CPU Optimization:
- Algorithm Complexity: Aim for $O(1)$ or $O(n)$ where possible; avoid $O(n^2)$ in critical paths.
- Offload Work: Move heavy computations to background threads or workers.
- Minimize Re-computation: Use memoization for pure, expensive functions.
🌐 Network & I/O
- Payload Reduction: Use efficient serialization (JSON minification, Protobuf) and compression.
- Batching: Group multiple small requests into single bulk operations.
- Caching Strategy:
- Implement multi-level caching (Memory -> Storage -> Network).
- Use appropriate TTL (Time To Live) and invalidation strategies.
- Non-blocking I/O: Always use asynchronous operations for file system and network access.
⚡ UI/UX Performance
- Minimize Main Thread Work: Keep animations and interactions fluid by keeping the main thread free.
- Virtualization: Use lazy loading or virtualization for long lists/large datasets.
- Tree Shaking: Ensure build tools remove unused code and dependencies.
📊 Monitoring & Testing
- Benchmarking: Write micro-benchmarks for performance-critical functions.
- SLIs/SLOs: Define Service Level Indicators (latency, throughput) and Objectives.
- Load Testing: Test system behavior under peak and stress conditions.
Source
git clone https://github.com/hoangnguyen0403/agent-skills-standard/blob/develop/.github/skills/common/performance-engineering/SKILL.mdView on GitHub Overview
Performance Engineering Standards define universal guidelines for building high-performance software across frameworks and languages. They emphasize efficiency by design, measurement-first tuning, smart resource management, and scalable architectures to reduce latency and resource usage.
How This Skill Works
Performance engineering begins with measuring baselines using profiling tools and validating improvements after changes. It promotes lightweight, scalable design by favoring O(1)/O(n) algorithms, memoization, lazy initialization, and offloading heavy work, while applying payload reduction, batching, multi-level caching, and non-blocking I/O; it also covers UI considerations like virtualization and tree shaking.
When to Use It
- During initial architecture design to ensure scalability from the start
- After profiling reveals hotspots or bottlenecks in CPU or memory
- In network or storage-heavy applications requiring payload reduction and caching
- For UI/UX focused apps where main thread work must be minimized
- When defining SLIs/SLOs and conducting load testing to validate performance targets
Quick Start
- Step 1: Profile the system and establish baselines using a profiler
- Step 2: Identify hotspots and apply optimizations (memoization, O(1)/O(n) algorithms, lazy initialization, offloading to workers)
- Step 3: Add monitoring (SLIs/SLOs), implement caching/batching, and run load tests; iterate
Best Practices
- Measure first: establish baselines with profiling tools before making changes
- Aim for efficient algorithms (O(1)/O(n)), use memoization for expensive pure functions, and minimize re-computation
- Enable lazy initialization and explicit cleanup to prevent memory leaks
- Apply multi-level caching with TTLs; use batching and efficient payload formats (e.g., minified JSON, Protobuf)
- Use non-blocking I/O, virtualization, and tree shaking; define SLIs/SLOs and perform regular load tests
Example Use Cases
- Backend service implements multi-level caching with TTL-based invalidation to meet latency targets
- Frontend application uses virtualization for long lists and tree-shaking to reduce bundle size
- Data processing workflow offloads heavy computations to background workers
- API payloads are serialized with Protobuf and requests are batched to reduce network overhead
- Baseline micro-benchmarks and SLIs/SLOs are defined, with load testing to validate performance targets
Frequently Asked Questions
Add this skill to your agents
