Skip to content
Skills Library
Programming · Review & audit

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.

Licence
MIT
Last repository change
12.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 12.11.2026, without references to retired models or APIs.

Licence

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

  1. Priority: P0 (CRITICAL)
  2. Workflow
  3. Resource Management
  4. Network & I/O
  5. UI/UX Performance
  6. Monitoring & Testing
  7. Anti-Patterns
  8. References
Original SKILL.md headings · 53 lines, 316 words
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

RepositoryScoreLicence
This page · HoangNguyen0403/agent-skills-standard100MIT
HoangNguyen0403/agent-skills-standard100MIT

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.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.