performance-engineer
Performance optimization specialist for improving application speed and efficiency. Use when investigating performance issues or optimizing code.
- Installs
- 709
- Last 24h
- —
- Trending rank
- —
- Security
- Not audited
Install
Works with every agent the skills CLI supports.
npx skills add https://github.com/zhaono1/agent-playbook --skill performance-engineer- 01
Install
Run the command in your project. The CLI asks which agents to install for.
- 02
Describe the task
Ask your agent for something this skill covers. It loads performance-engineer automatically when relevant.
- 03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.
SKILL.md
The instructions your agent reads when the skill is triggered.
Performance Engineer
Specialist in analyzing and optimizing application performance, identifying bottlenecks, and implementing efficiency improvements.
When This Skill Activates
Activates when you:
- Report performance issues
- Need performance optimization
- Mention "slow" or "latency"
- Want to improve efficiency
Performance Analysis Process
Phase 1: Identify the Problem
-
Define metrics
- What's the baseline?
- What's the target?
- What's acceptable?
-
Measure current performance
# Response time curl -w "@curl-format.txt" -o /dev/null -s https://example.com/users # Database query time # Add timing logs to queries # Memory usage # Use profiler -
Profile the application
# Node.js node --prof app.js # Python python -m cProfile app.py # Go go test -cpuprofile=cpu.prof
Phase 2: Find the Bottleneck
Common bottleneck locations:
| Layer | Common Issues |
|---|---|
| Database | N+1 queries, missing indexes, large result sets |
| API | Over-fetching, no caching, serial requests |
| Application | Inefficient algorithms, excessive logging |
| Frontend | Large bundles, re-renders, no lazy loading |
| Network | Too many requests, large payloads, no compression |
Phase 3: Optimize
Database Optimization
N+1 Queries:
// Bad: N+1 queries
const users = await User.findAll();
for (const user of users) {
user.posts = await Post.findAll({ where: { userId: user.id } });
}
// Good: Eager loading
const users = await User.findAll({
include: [{ model: Post, as: 'posts' }]
});
Missing Indexes:
-- Add index on frequently queried columns
CREATE INDEX idx_user_email ON users(email);
CREATE INDEX idx_post_user_id ON posts(user_id);
API Optimization
Pagination:
// Always paginate large result sets
const users = await User.findAll({
limit: 100,
offset: page * 100
});
Field Selection:
// Select only needed fields
const users = await User.findAll({
attributes: ['id', 'name', 'email']
});
Compression:
// Enable gzip compression
app.use(compression());
Frontend Optimization
Code Splitting:
// Lazy load routes
const Dashboard = lazy(() => import('./Dashboard'));
Memoization:
// Use useMemo for expensive calculations
const filtered = useMemo(() =>
items.filter(item => item.active),
[items]
);
Image Optimization:
- Use WebP format
- Lazy load images
- Use responsive images
- Compress images
Phase 4: Verify
- Measure again
- Compare to baseline
- Ensure no regressions
- Document the improvement
Performance Targets
Derive targets from the service SLO, current baseline, workload shape, cost budget, and critical user journey. The table below is an example starting point only; never present it as the system's acceptance criteria without evidence or owner agreement.
| Metric | Target | Critical Threshold |
|---|---|---|
| API Response (p50) | < 100ms | < 500ms |
| API Response (p95) | < 500ms | < 1s |
| API Response (p99) | < 1s | < 2s |
| Database Query | < 50ms | < 200ms |
| Page Load (FMP) | < 2s | < 3s |
| Time to Interactive | < 3s | < 5s |
| Memory Usage | < 512MB | < 1GB |
Common Optimizations
Caching Strategy
// Cache expensive computations
const cache = new Map();
async function getUserStats(userId: string) {
if (cache.has(userId)) {
return cache.get(userId);
}
const stats = await calculateUserStats(userId);
cache.set(userId, stats);
// Invalidate after 5 minutes
setTimeout(() => cache.delete(userId), 5 * 60 * 1000);
return stats;
}
Batch Processing
// Bad: Individual requests
for (const id of userIds) {
await fetchUser(id);
}
// Good: Batch request
await fetchUsers(userIds);
Debouncing/Throttling
// Debounce search input
const debouncedSearch = debounce(search, 300);
// Throttle scroll events
const throttledScroll = throttle(handleScroll, 100);
Performance Monitoring
Key Metrics
- Response Time: Time to process request
- Throughput: Requests per second
- Error Rate: Failed requests percentage
- Memory Usage: Heap/RAM used
- CPU Usage: Processor utilization
Monitoring Tools
| Tool | Purpose |
|---|---|
| Lighthouse | Frontend performance |
| New Relic | APM monitoring |
| Datadog | Infrastructure monitoring |
| Prometheus | Metrics collection |
Scripts
Profile application:
python3 scripts/profile.py --name <service-name> --output perf-profile.txt
Generate performance report:
python3 scripts/perf_report.py --name <service-name> --output perf-report.md
References
references/optimization.md- Optimization techniquesreferences/monitoring.md- Monitoring setupreferences/checklist.md- Performance checklist
FAQ
What does the performance-engineer skill do?
Performance optimization specialist for improving application speed and efficiency. Use when investigating performance issues or optimizing code.
How do I install performance-engineer?
Run npx skills add https://github.com/zhaono1/agent-playbook --skill performance-engineer in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/performance-engineer/ (personal) or .claude/skills/performance-engineer/ (project).
Which AI agents can use performance-engineer?
Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.
Is performance-engineer safe to install?
No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.
Who maintains performance-engineer?
It is published by zhaono1 in zhaono1/agent-playbook. It has 709 recorded installs.
More from zhaono1/agent-playbook
self-improving-agent
zhaono1/agent-playbook
Use after a failure, user correction, repeated workflow problem, or validated success reveals a reusable lesson. Captures bounded redacted candidates, runs executable behavior evals, and separates validation from application in durable guidance.
planning-with-files
zhaono1/agent-playbook
Uses persistent markdown files for general planning, progress tracking, and knowledge storage (Manus-style workflow). Use for multi-step tasks, research projects, or general organization WITHOUT mentioning PRD. For PRD-specific work, use prd-planner skill instead.
security-auditor
zhaono1/agent-playbook
Security vulnerability expert covering OWASP Top 10 and common security issues. Use when conducting security audits or reviewing code for vulnerabilities.
architecting-solutions
zhaono1/agent-playbook
Designs technical solutions and architecture. Use when user says "design solution", "architecture design", "technical design", or "方案设计" WITHOUT mentioning PRD. For PRD-specific work, use prd-planner skill instead.
skill-router
zhaono1/agent-playbook
Routes an agent request to the narrowest matching portable skill when the user asks which skill to use or needs help selecting one across supported hosts.
workflow-orchestrator
zhaono1/agent-playbook
Coordinates multi-skill workflows and records or runs follow-up actions when the host runtime supports them. Use when completing PRD creation, implementation, or any milestone that should be evaluated for additional skills.
Popular code quality & workflow skills
grill-me
mattpocock/skills
A relentless interview to sharpen a plan or design.
improve-codebase-architecture
mattpocock/skills
Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.
handoff
mattpocock/skills
Compact the current conversation into a handoff document for another agent to pick up.
domain-modeling
mattpocock/skills
Build and sharpen a project's domain model. Use when discussing codebase terminology, writing or editing a GLOSSARY.md, or recording or editing an ADR.
codebase-design
mattpocock/skills
Shared vocabulary for designing deep modules. Use when the user wants to design or improve a module's interface, find deepening opportunities, decide where a seam goes, make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.
diagnosing-bugs
mattpocock/skills
Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow.