Performance Test Engineer's Assistant
Analyze performance bottlenecks and generate load tests instantly
What You Can Do
You can analyze performance metrics from your applications to identify bottlenecks, automatically generate load test scripts tailored to your system architecture, and create detailed performance reports with actionable optimization recommendations. This skill processes performance data from various monitoring tools and transforms it into load testing strategies and optimization plans that your team can execute immediately.
Features
Parse and analyze metrics from monitoring tools to identify performance patterns and anomalies
Automatically pinpoint CPU, memory, I/O, and network bottlenecks causing performance degradation
Create ready-to-run load test scripts for tools like JMeter, Locust, and k6 based on your system requirements
Define and document baseline metrics to track improvements over time
Identify performance trends and predict future capacity needs
Generate specific, prioritized recommendations to improve application performance
Create professional performance reports with findings and action items
Help define appropriate alerting thresholds based on historical performance data
Example Output
Example 1: Bottleneck Analysis Report
## Performance Analysis Results
- Database Query Time: 450ms (45% of total latency) — CRITICAL
- API Response Caching: Missing on 60% of requests — HIGH IMPACT
- Memory Usage: 78% during peak — Monitor closely
## Immediate Actions
1. Add query indexing on user_id and created_at fields
2. Implement 5-minute TTL cache for user profile endpoints
3. Scale memory allocation to 16GB (from 8GB)
Example 2: Generated Load Test Script (k6)
import http from 'k6/http';
import { check, sleep } from 'k6';
export let options = {
stages: [
{ duration: '2m', target: 100 },
{ duration: '5m', target: 500 },
{ duration: '2m', target: 0 },
],
};
export default function() {
let res = http.get('https://api.example.com/users');
check(res, { 'status is 200': (r) => r.status === 200 });
sleep(1);
}
Example 3: Optimization Recommendations
Priority | Recommendation | Est. Impact | Effort
---------|---|---|---
P1 | Add Redis caching | 40% latency reduction | 3 days
P1 | Optimize DB queries | 25% latency reduction | 2 days
P2 | Enable HTTP/2 compression | 15% bandwidth reduction | 1 day
P3 | Implement CDN for assets | 30% delivery speed | 5 days
What's Included
- SKILL.md: Complete Claude skill definition with performance analysis workflows
- Performance Analysis Template: Structured template for analyzing metrics from monitoring tools
- Load Test Script Templates: Ready-to-adapt templates for JMeter, Locust, and k6
- Performance Report Template: Professional report structure with findings and recommendations
- Bottleneck Diagnosis Checklist: Step-by-step guide to identify common performance issues
- Baseline Establishment Workflow: Process to document and track performance baselines
- Optimization Priority Matrix: Framework for prioritizing performance improvements
Who It's For
- Performance Engineers — Analyzing metrics and creating optimization strategies
- QA Engineers — Running performance tests and validating improvements
- DevOps Engineers — Monitoring production performance and scaling infrastructure
- Site Reliability Engineers (SREs) — Establishing SLOs and performance baselines
- Backend Engineers — Identifying and fixing performance issues in code
Best For
- Analyzing performance test results and identifying bottlenecks
- Generating load test scripts for your specific use cases
- Creating performance reports for stakeholders
- Establishing baseline metrics and tracking performance over time
- Generating optimization recommendations based on performance data
You might also like
Rapidly analyze production incidents by correlating observability signals—logs, metrics, traces, and events—to identify the true root cause instead of symptoms. You'll reconstruct incident timelines, quantify impact scope, and generate both immediate remediation steps and long-term prevention measures.
Claude analyzes your code diffs and generates standardized commit messages that follow the Conventional Commits specification. The skill automatically determines the correct commit type, scope, and description based on the changes you've made, ensuring your messages are parseable by automation tools while remaining human-readable for code reviewers.
You'll transform high-level feature requirements into a complete development plan covering API design, frontend implementation, testing strategy, and documentation. The skill helps you identify dependencies, parallelize work across frontend and backend teams, and establish quality gates that ensure features ship bug-free with proper error handling and logging.
Transform schema and data changes into production-ready migration packages that protect data integrity and minimize downtime. You can handle column additions, renames, type conversions, and backfills using proven patterns like expand-contract and shadow tables. The skill generates explicit rollback scripts, validation checklists, and phased execution plans that keep applications stable throughout the migration.
You can create comprehensive performance testing strategies tailored to your application's architecture, analyze test results to identify bottlenecks, and generate prioritized recommendations for optimization. The skill helps you design load tests, interpret metrics like latency and throughput, and create action plans for performance improvements.
You can design comprehensive performance test strategies tailored to your application architecture, analyze performance metrics and logs to identify bottlenecks, and receive specific optimization recommendations. The skill guides you through creating realistic load scenarios, interpreting performance data, and prioritizing fixes based on impact analysis.
You can design end-to-end NGS pipelines tailored to your experiment type (WGS, WES, RNA-seq, targeted), troubleshoot pipeline failures by analyzing QC metrics and logs, and optimize performance by fine-tuning parameters and identifying bottlenecks. This skill handles the full workflow from raw sequencing data quality assessment through variant interpretation and annotation.
You can accelerate your entire antenna design workflow—from initial concept to optimized specifications—by leveraging Claude's knowledge of electromagnetic theory, antenna types, and design trade-offs. Claude helps you parameterize designs, identify optimal configurations for your frequency band and application, and prepare detailed briefs for simulation and manufacturing. You'll generate design reviews, impedance-matching solutions, and validation checklists without context-switching to multiple tools.