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
You'll develop systematic approaches to injectable formulation design, from API selection through sterilization strategy. Claude helps you troubleshoot failed batches by analyzing root causes, recommends regulatory pathways (505(b)(2), ANDA, NDA), and provides science-backed solutions for stability, compatibility, and manufacturability challenges.
This skill helps you systematically assess integration needs across your systems, design architecture patterns that scale with your organization, and identify technical and operational risks before implementation. You'll receive architecture recommendations aligned to your business constraints, clear integration roadmaps, and risk mitigation strategies that reduce deployment surprises. Get structured decision records suitable for architecture review boards and engineering teams.
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 can transform raw text into structured, labeled datasets for machine learning, analysis, and research. This skill performs named entity recognition, sentiment classification, part-of-speech tagging, and dependency parsing—generating consistent, validated annotations at scale. Use it to prepare corpora, extract entities, classify documents, or perform linguistic analysis without manual annotation.
This skill helps you systematically analyze service mesh architectures, identify inter-service communication failures, and design optimal routing and security policies. You'll receive step-by-step troubleshooting guidance tailored to your mesh platform (Istio, Linkerd, Consul), configuration validation reports, and architectural recommendations that reduce latency, improve observability, and tighten security posture.
This skill automates the creation of production-ready deployment validation checklists, infrastructure-as-code templates, and incident response runbooks tailored to your ML stack. You get comprehensive pre-deployment checks covering model validation, data pipeline integrity, infrastructure readiness, and monitoring setup—all customized for your specific models and cloud provider. The skill generates executable runbooks that teams can follow during incidents, including rollback procedures, failover strategies, and diagnostic commands.
Build scalable internal developer platform architectures that reduce cognitive load and standardize workflows for your development organization. Document golden paths that guide developers through common tasks like onboarding, deployment, and troubleshooting. Map platform capabilities, integrations, and service topology to align with your engineering scale and technical strategy.
Rapidly analyze firmware logs and diagnose hardware issues that cause device failures, connectivity problems, and performance degradation. You'll identify root causes from stack traces, crash dumps, and sensor data, then generate specific optimization recommendations. This skill transforms raw device logs into actionable debugging plans that reduce time-to-resolution from hours to minutes.