home / skills / d-oit / do-novelist-ai / performance-engineer

performance-engineer skill

safe

This skill helps you optimize application performance across build time, runtime, and bundle size by guiding measurement, profiling, and incremental

npx playbooks add skill d-oit/do-novelist-ai --skill performance-engineer

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

Files (3)

SKILL.md

2.1 KB

---
name: performance-engineer
description:
  Optimize application performance including build times, runtime speed, bundle
  size and resource usage. Use when addressing performance issues, implementing
  caching strategies, or optimizing rendering.
---

# Performance Engineer

Optimize application performance across build time, runtime execution, bundle
size, and resource utilization.

## Quick Reference

- **[Core Guidance](core-guidance.md)** - Performance methodology and principles
- **[Optimization Strategies](optimization-strategies.md)** - Caching, parallel
  processing, monitoring

## When to Use

- Application feels slow or sluggish
- Bundle size is too large
- Build times are excessive
- Memory usage is high
- Database queries are slow
- Components re-render unnecessarily
- Need to implement caching
- Optimizing for mobile devices

## Core Methodology

Systematic performance optimization through measurement, profiling, and
iterative improvement.

**Key Principles**:

1. Measure before optimizing
2. Focus on bottlenecks first
3. Profile to find actual hot spots
4. Optimize incrementally with validation
5. Monitor performance metrics continuously
6. Balance performance with code maintainability

## Integration

- **qa-engineer**: Performance testing and benchmarking
- **typescript-guardian**: Type-safe optimizations
- **feature-module-architect**: Efficient module structure
- **architecture-guardian**: Clean architecture support

## Best Practices

✓ Profile before optimizing ✓ Focus on measured bottlenecks ✓ Use caching
strategies ✓ Implement parallel processing ✓ Monitor continuously ✓ Optimize
incrementally

✗ Optimize without measuring ✗ Optimize theoretical bottlenecks ✗ Over-optimize
rare paths ✗ Ignore performance metrics ✗ Make large changes at once

---

## Content Modules

See detailed modules:

- **[Core Guidance](core-guidance.md)** - Performance principles
- **[Optimization Strategies](optimization-strategies.md)** - Caching, parallel
  processing

Optimize performance systematically through measurement, profiling, and
incremental improvement.

Overview

This skill helps optimize application performance across build times, runtime speed, bundle size, and resource usage. It guides a systematic workflow: measure, profile, prioritize hotspots, apply targeted optimizations, and validate results. Use it to diagnose slow builds, heavy bundles, excessive memory use, or inefficient rendering.

How this skill works

The skill inspects performance metrics and guides profiling to identify real bottlenecks rather than assumptions. It recommends concrete tactics—caching, parallelization, code-splitting, and incremental changes—and integrates monitoring to validate improvements. It maps optimizations to likely causes (build, runtime, memory, network) and suggests targeted fixes.

When to use it

Application or UI feels sluggish for users
Build times or CI pipelines are excessively long
Bundle size causes slow load times or high bandwidth costs
Memory or CPU usage is high in production
Database queries or backend endpoints are slow or inconsistent

Best practices

Measure and profile before making changes; use real workloads and representative devices
Prioritize fixes by impact and cost; attack the largest bottlenecks first
Run incremental, validated changes with performance tests and benchmarks
Use caching and CDN strategies where appropriate; prefer cache-first for stable data
Split bundles and use lazy loading to reduce initial payload; keep hot paths small
Monitor continuously in staging and production to detect regressions early

Example use cases

Reduce initial load time by analyzing bundle composition and implementing code-splitting
Shorten CI build times by parallelizing tasks and caching build artifacts
Lower runtime CPU/memory by profiling hot functions and optimizing algorithms
Improve perceived performance by deferring non-critical rendering and applying lazy hydration
Add caching and TTL strategies for expensive API calls to cut latency and backend load

FAQ

How do I know where to start optimizing?

Start with measurement: collect metrics for build time, bundle size, runtime CPU/memory, and user-perceived load. Profile the slowest user flows to find true hotspots and rank them by impact.

Can I optimize without breaking functionality?

Yes—optimize incrementally with tests and monitoring. Make small, reversible changes, run benchmarks, and use feature flags to roll out improvements safely.