Skip to content
Skills Library
Programming · Testing

load-testing

/load-testing

Load and performance testing. k6 (Grafana), Artillery, Apache JMeter, Locust (Python). Scenario design, thresholds, ramp-up patterns, and CI/CD integration. USE WHEN: user mentions "load test", "performance test", "stress test", "k6", "Artillery", "JMeter", "Locust", "throughput", "benchmarking" DO NOT USE FOR: unit/integration testing - use testing skills; monitoring in production - use `opentelemetry`

Licence
MIT
Last repository change
21.10.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
1
Scripts
0
HTML comments
0
URLs in SKILL.md
6
Deprecation

No signals detected. Repository changed on 21.10.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

Load and performance testing. k6 (Grafana), Artillery, Apache JMeter, Locust (Python). Scenario design, thresholds, ramp-up patterns, and CI/CD integration. USE WHEN: user mentions "load test", "performance test", "stress test", "k6", "Artillery", "JMeter", "Locust", "throughput", "benchmarking" DO NOT USE FOR: unit/integration testing - use testing skills; monitoring in production - use `opentelemetry`

Triggers from the description

load testperformance teststress testArtilleryJMeterLocustthroughputbenchmarking
Original author description

Load and performance testing. k6 (Grafana), Artillery, Apache JMeter, Locust (Python). Scenario design, thresholds, ramp-up patterns, and CI/CD integration. USE WHEN: user mentions "load test", "performance test", "stress test", "k6", "Artillery", "JMeter", "Locust", "throughput", "benchmarking" DO NOT USE FOR: unit/integration testing - use testing skills; monitoring in production - use `opentelemetry`

How it works

  1. k6 (recommended)
  2. Artillery
  3. Locust (Python)
  4. Test Types
  5. Anti-Patterns
  6. Production Checklist
Original SKILL.md headings · 146 lines, 523 words
SKILL.md preview
---
name: load-testing
description: |
  Load and performance testing. k6 (Grafana), Artillery, Apache JMeter,
  Locust (Python). Scenario design, thresholds, ramp-up patterns,
  and CI/CD integration.

  USE WHEN: user mentions "load test", "performance test", "stress test",
  "k6", "Artillery", "JMeter", "Locust", "throughput", "benchmarking"

  DO NOT USE FOR: unit/integration testing - use testing skills;
  monitoring in production - use `opentelemetry`
allowed-tools: Read, Grep, Glob, Write, Edit
---
# Load Testing

## k6 (recommended)

```javascript
// load-test.js
import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 50 },   // Ramp up to 50 users
    { duration: '3m', target: 50 },   // Stay at 50
    { duration: '1m', target: 100 },  // Ramp to 100
    { duration: '3m', target: 100 },  // Stay at 100
    { duration: '1m', target: 0 },    // Ramp down
  ],
  thresholds: {
    http_req_duration: ['p(95)<500', 'p(99)<1000'], // 95th < 500ms
    http_req_failed: ['rate<0.01'],                  // <1% error rate
  },
};

export default function () {
  const res = http.get('https://api.example.com/products');
  check(res, {
    'status is 200': (r) => r.status === 200,
    'response time < 500ms': (r) => r.timings.duration < 500,
  });
  sleep(1);
}
```

### Authenticated Requests

```javascript
import http from 'k6/http';

export function setup() {
  const res = http.post('https://api.example.com/auth/login', JSON.stringify({
    email: 'loadtest@example.com', password: 'test-password',
  }), { headers: { 'Content-Type': 'application/json' } });
  return { token: res.json('token') };
}

export default function (data) {
  const headers = { Authorization: `Bearer ${data.token}`, 'Content-Type': 'application/json' };

  // Simulate user journey
  http.get('https://api.example.com/products', { headers });
  sleep(2);
  http.get('https://api.example.com/products/1', { headers });
  sleep(1);
  http.post('https://api.example.com/orders', JSON.stringify({ productId: '1', qty: 2 }), { headers });
}
```

## Artillery

```yaml
# artillery.yml
config:
  target: "https://api.example.com"
  phases:
    - duration: 60
      arrivalRate: 10
      name: "Warm up"
    - duration: 120
      arrivalRate: 50
      name: "Sustained load"
  defaults:
    headers:
      Content-Type: "application/json"

scenarios:
  - name: "Browse and purchase"
    flow:
      - get:
          url: "/products"
          capture:
            - json: "$.data[0].id"
              as: "productId"
      - think: 2
      - get:
          url: "/products/{{ productId }}"
      - think: 1
      - post:
          url: "/orders"
          json:
            productId: "{{ productId }}"
            quantity: 1
```

## Locust (Python)

```python
from locust import HttpUser, task, between

class WebUser(HttpUser):
    wait_time = between(1, 3)

    def on_start(self):
        res = self.client.post("/auth/login", json={
            "email": "test@example.com", "password": "password"
        })
        self.token = res.json()["token"]
        self.headers = {"Authorization": f"Bearer {self.token}"}

    @task(3)
    def browse_products(self):
        self.client.get("/products", headers=self.headers)

    @task(1)
    def create_order(self):
        self.client.post("/orders", json={"productId": "1", "qty": 1}, headers=self.headers)
```

## Test Types

| Type | Purpose | Duration |
|------|---------|----------|
| Smoke | Verify system works under minimal load | 1-2 min |
| Load | Expected normal/peak traffic | 10-30 min |
| Stress | Beyond normal capacity, find breaking point | 10-20 min |
| Soak | Sustained load to find memory leaks | 1-4 hours |
| Spike | Sudden traffic burst | 5-10 min |

## Anti-Patterns

| Anti-Pattern | Fix |
|--------------|-----|
| Testing from same network as server | Test from external network or cloud |
| No think time between requests | Add realistic `sleep`/`think` delays |
| Single endpoint only | Test realistic user journeys |
| No thresholds defined | Set p95/p99 latency and error rate thresholds |
| Running load tests against production | Use staging environment |

## Production Checklist

- [ ] Realistic user scenarios (not just single endpoints)
- [ ] Thresholds for latency (p95, p99) and error rate
- [ ] Ramp-up pattern matching expected traffic shape
- [ ] Test data seeded (not reusing same record)
- [ ] CI/CD integration for regression detection
- [ ] Results archived for comparison over time

Versions

RepositoryScoreLicence
This page · claude-dev-suite/claude-dev-suite100MIT
SkillMedev/skills100MIT
ajyadav013/claude-kit100MIT
ajyadav013/claude-kit100MIT
rnavarych/alpha-engineer100MIT
VilnaCRM-Org/rust-service-template96CC0-1.0
OKHP3/skillz90MIT
Amey-Thakur/AI-SKILLS90MIT
arjunprabhulal/devops-skills90MIT

Database snapshot: 13.11.2026 · package version 397af60b7929 (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

  • 90quality-load-testing
    Use this skill when setting up load testing, performance testing, stress tests, k6, Locust, artillery, JMeter, or benchmarking throughput and latency. This skill enforces: scenario design (load, stress, spike, soak), metric collection (latency p50/p95/p99, throughput, error…
  • 90backend-load-testing
    Use this skill when the user says 'load test', 'stress test', 'soak test', 'spike test', 'k6', 'Locust', 'Artillery', 'performance test', 'benchmark', 'throughput', 'RPS', 'latency p99', 'CI performance', 'regression test', 'load test results', or when planning performance…
  • 100artillery
    When the user wants to design, implement, debug, or operate Artillery load tests. Use when the user mentions "Artillery," "artillery.yml," "artillery run," "Artillery scenarios," "Artillery Pro," "phases (Artillery)," "Artillery plugins," "Artillery Engine," or "artillery…
  • 100k6
    When the user wants to design, implement, debug, or operate k6 load tests. Use when the user mentions "k6," "Grafana k6," "k6 run," "k6 scenarios," "k6 thresholds," "vus," "iterations," "ramping-vus," "constant-arrival-rate," "k6 cloud," "xk6," "k6-operator," or "checks vs…
  • 100loadtest
    Load testing and performance testing skill. k6, Artillery, Locust, JMeter. Stress, spike, soak testing. Statistical significance checking. Triggers on: /godmode:loadtest, "load test", "stress test", "performance test", "benchmark".
  • 100artillery
    When the user wants to perform load testing or performance testing using Artillery with YAML-based scenario definitions. Also use when the user mentions "artillery," "YAML load test," "WebSocket testing," "Socket.io load test," "scenario-based load testing," or "artillery run."…

Feedback and reports

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