common-performance-engineering
/common-performance-engineering
Enforce universal standards for high-performance development. Use when profiling bottlenecks, reducing latency, fixing memory leaks, improving throughput, or optimizing algorithm complexity in any language.
- Author
- HoangNguyen0403 ↗
- Repository
- agent-skills-standard ↗
- Licence
- MIT
- Last repository change
- 22.10.2026
Assessment and security
- Files in this package
- 3
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 22.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Enforce universal standards for high-performance development. Use when profiling bottlenecks, reducing latency, fixing memory leaks, improving throughput, or optimizing algorithm complexity in any language.
Original author description
Enforce universal standards for high-performance development. Use when profiling bottlenecks, reducing latency, fixing memory leaks, improving throughput, or optimizing algorithm complexity in any language.
How it works
- Priority: P0 (CRITICAL)
- Workflow
- Resource Management
- Network & I/O
- UI/UX Performance
- Monitoring & Testing
- Anti-Patterns
- References
- Canonical response anchors
SKILL.md preview
---
name: common-performance-engineering
description: Enforce universal standards for high-performance development. Use when profiling bottlenecks, reducing latency, fixing memory leaks, improving throughput, or optimizing algorithm complexity in any language.
metadata:
triggers:
files:
- '**/*.ts'
- '**/*.tsx'
- '**/*.go'
- '**/*.dart'
- '**/*.java'
- '**/*.kt'
- '**/*.swift'
- '**/*.py'
keywords:
- performance
- optimize
- profile
- scalability
- latency
- throughput
- memory leak
- bottleneck
---
# Performance Engineering Standards
## **Priority: P0 (CRITICAL)**
## Workflow
1. **Baseline**: Profile before changing anything — measure CPU, memory, and latency.
2. **Identify**: Find top bottleneck (N+1 query, hot loop, memory leak).
3. **Fix**: Apply targeted optimization from sections below.
4. **Verify**: Re-profile to confirm improvement and check for regressions.
## Resource Management
- **Memory Efficiency**:
- Avoid memory leaks: explicit cleanup of listeners, observers, and streams.
- Optimize data structures: `Set` for lookups, `List` for iteration.
- Lazy Initialization: Initialize expensive objects only when needed.
- **CPU Optimization**:
- Aim for O(1) or O(n); avoid O(n^2) in critical paths.
- Offload heavy computations to background threads or workers.
- Memoize pure, expensive functions.
See [implementation examples](references/implementation.md) for memoization and batching patterns.
## Network & I/O
- **Payload Reduction**: Use efficient serialization (Protobuf, JSON minification) and compression (gzip/br).
- **Batching**: Group multiple small requests into single bulk operations.
- **Caching**: Implement multi-level caching (Memory -> Storage -> Network) with appropriate TTL and invalidation.
- **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 offloading to workers.
- **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.
## Anti-Patterns
- **No premature optimization**: Profile first, fix proven bottlenecks only.
- **No N+1 queries**: Always batch and paginate data-access operations.
- **No synchronous I/O on main thread**: Async all file/network access.
## References
- [Implementation Patterns](references/implementation.md) — profiling patterns, benchmark setup
## Canonical response anchors
When this skill applies, preserve the following domain terminology or equivalent concrete examples in the answer when relevant:
- lazy
- Additional task-grounded exact anchors: premature
Files in this package (3)
- LICENSE 1 KB
- SKILL.md 3 KB
- references/implementation.md 1 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · HoangNguyen0403/agent-skills-standard | 100 | MIT |
| HoangNguyen0403/agent-skills-standard | 100 | MIT |
Identical content appears in 4 other GitHub folders. We show one copy with the highest score.
Database snapshot: 13.11.2026 · package version 700f9ff3e005 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100performance-engineering
Use when investigating latency spikes, optimizing frontend rendering/bundle sizes, resolving database query bottlenecks, profiling memory leaks or event loop lag, or load testing services. - 100python-performance-optimization
Python performance optimization patterns using profiling, algorithmic improvements, and acceleration techniques. Use when optimizing slow Python code, reducing memory usage, or improving application throughput and latency. - 100python-performance
Profiles Python code for performance bottlenecks and memory issues. Use when Python code is slow or when profiling for optimization before a release. - 100performance-investigation
Diagnose a measured latency, memory, throughput, or resource regression and propose the smallest supported optimization. Use for performance questions; measure before tuning. - 100sota-performance
State-of-the-art performance engineering for building fast systems and auditing existing code for bottlenecks. Use when the task involves performance, optimization, latency, profiling, slow code, memory usage, caching, or throughput — designing latency budgets, fixing N+1 and… - 100optimization
Use when improving performance, latency, throughput, memory usage, or general efficiency. Start by defining target metrics, measuring comprehensively, attributing bottlenecks, validating with static analysis, and prioritizing macro-optimizations before micro-optimizations.