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
- 12.11.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 12.11.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
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
- profiling
- 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; for API workloads, follow [API Performance Testing](../../quality-engineering/quality-engineering-api-performance-testing/SKILL.md) for workload modeling, percentiles, and recovery bounds.
## 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
- [API Performance Testing](../../quality-engineering/quality-engineering-api-performance-testing/SKILL.md) — workload models, latency percentiles, overload recovery
Files in this package (3)
- SKILL.md 3 KB
- evals/evals.json 2 KB
- references/implementation.md 1 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · HoangNguyen0403/agent-skills-standard | 100 | MIT |
| HoangNguyen0403/agent-skills-standard | 100 | MIT |
Database snapshot: 13.11.2026 · package version ce02b6490644 (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
- 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-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. - 100performance-review
Performance optimization analysis: CPU/memory profiling, caching strategies, database query optimization, connection pooling, concurrency patterns, memory leak detection, and throughput improvement. Use when code is slow, memory usage is high, latency needs reduction, or… - 88dev-loop-performance-profiler
Use when the user asks about performance profiling, application performance, profiling tools, performance optimization, bottleneck analysis, or performance testing. Do NOT use for: debugging bugs (dev-loop-debugging-strategy), or code review (dev-loop-code-review). - 100performance-optimization
Optimizes application performance across frontend, backend, queries, and databases. Use when performance requirements exist, when you suspect performance regressions, when Core Web Vitals or load times need improvement, when N+1 query patterns need fixing, or when profiling reveals bottlenecks.