home / skills / hoangnguyen0403 / agent-skills-standard / performance-engineering

performance-engineering skill

safe

This skill helps you apply universal performance standards across languages and frameworks to optimize efficiency, profiling, and scalability.

npx playbooks add skill hoangnguyen0403/agent-skills-standard --skill performance-engineering

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.5 KB

---
name: Performance Engineering Standards
description: Universal standards for high-performance software development across all frameworks.
metadata:
  labels: [performance, optimization, scalability, profiling]
  triggers:
    keywords: [performance, optimize, profile, scalability]
---

# 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., `Set` for lookups, `List` for 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.

Overview

This skill captures universal performance engineering standards for building high-performance software across languages and frameworks. It provides concise, framework-agnostic rules and patterns that guide resource management, networking, UI responsiveness, and observability. Use it to align agents and teams on measurable, repeatable performance practices.

How this skill works

The skill inspects code and architecture choices against core principles: measure before optimizing, minimize resource consumption, and design for scalability. It highlights memory and CPU pitfalls, recommends async and non-blocking I/O patterns, and suggests caching, batching, and serialization strategies. It also prescribes monitoring, benchmarking, and SLIs/SLOs to validate improvements.

When to use it

When reviewing code for runtime and resource efficiency across platforms (mobile, web, backend).
When defining performance requirements, SLIs, and SLOs for a service or component.
During architecture design to choose data structures, async patterns, and caching strategies.
When diagnosing latency, throughput, or memory problems in production or staging.
Before deploying large releases to ensure changes don’t regress critical performance metrics.

Best practices

Measure first with profiling and benchmarks; use results to prioritize optimizations.
Prefer appropriate data structures (e.g., Set for membership, List for ordered iteration).
Avoid blocking the main thread; offload heavy work to workers or background tasks.
Implement multi-level caching and clear TTL/invalidation rules to reduce repeated work.
Use efficient serialization and batching to reduce network overhead and I/O stalls.

Example use cases

Optimize a mobile app: remove memory leaks, virtualize long lists, and move heavy parsing off the main thread.
Improve API performance: add request batching, compress payloads, and introduce multi-level caching with proper invalidation.
Harden a microservice: add micro-benchmarks for hot paths, set SLIs for latency, and run load tests before scaling.
Refactor a web app bundle: enable tree shaking, lazy-load modules, and eliminate unused dependencies to reduce startup time.

FAQ

Should I optimize before measuring?

No. Always establish a baseline with profiling and metrics, then target the highest-impact hotspots.

How do I choose cache TTL?

Balance freshness and cost: choose TTL based on data volatility, read/write patterns, and acceptable staleness for consumers.