Agent skill

Running Performance Tests

by jeremylongshore in jeremylongshore/tons-of-skills-marketplace

Execute load testing, stress testing, and performance benchmarking.

MITAuto-check passedTesting & QA

Install Running Performance Tests

skills CLI
$ npx skills add jeremylongshore/tons-of-skills-marketplace --skill running-performance-tests -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install jeremylongshore/tons-of-skills-marketplace running-performance-tests --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/jeremylongshore/tons-of-skills-marketplace.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/.curated/running-performance-tests .claude/skills/running-performance-tests && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
running-performance-tests
GitHub stars
2.8k
Token cost
~1.5k tokens
SKILL.md length
540 words
Files
10 (incl. scripts, references, assets)
Skills in repo
3,342
Repo updated
First seen
Licence
MIT

At a glance

Execute load testing, stress testing, and performance benchmarking.

  • Works in 7 steps: Define performance test scenarios based… → Create test scripts targeting critical… → Configure load profiles → …
  • Performing specialized testing
  • SKILL.md covers Overview, Prerequisites, Instructions and Output, plus 3 more sections
  • Runs Python and JavaScript scripts from its folder; reaches api.test.com

What it does

Running Performance Tests is an agent skill from jeremylongshore/tons-of-skills-marketplace. Execute load testing, stress testing, and performance benchmarking. Use when performing specialized testing. Trigger with phrases like "run load tests", "test performance", or "benchmark the system".

Its SKILL.md is about 1.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 12 other files, including scripts, reference files and assets (for example `assets/README.md`, `assets/example_test_configurations.json` and `assets/test_template.js`). Compatibility notes: Designed for Claude Code

It sits in Testing & QA, covering Load testing. The repository describes itself as: Model-agnostic agent-skills platform with a harness-free canonical layer, verified adapters, and the ccpi package manager. Explore at tonsofskills.com. The licence is MIT.

When your agent uses it

  • Performing specialized testing
  • With phrases like run load tests
  • Test performance
  • Benchmark the system

Example prompts

  • “run load tests”
  • “test performance”
  • “benchmark the system”
  • “/running-performance-tests”

Requirements

  • Python 3
  • Node.js
  • Compatibility (from SKILL.md): Designed for Claude Code
  • Pre-approved tools (allowed-tools): Read, Write, Edit, Grep, Glob, Bash(test:perf-*)

Workflow steps

7 steps, taken from the first numbered list in SKILL.md.

  1. Define performance test scenarios based on production traffic patterns
  2. Create test scripts targeting critical endpoints
  3. Configure load profiles
  4. Execute the performance test
  5. Analyze results against SLA thresholds
  6. Identify and document bottlenecks
  7. Generate a performance report with visualizations and recommendations.

What it can do on your machine

Read from SKILL.md and the folder at commit cfae287. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Write
    • Edit
    • Grep
    • Glob
    • Bash(test:perf-*)

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 4 files in scripts/ (Python and JavaScript), which the agent can run.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • api.test.com

    Also links to:

    • grafana.com
    • artillery.io
    • docs.locust.io
    • jmeter.apache.org
    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    Designed for Claude Code

    From compatibility in the SKILL.md frontmatter.

Context cost

Running Performance Tests loads about 1.5k tokens when it runs, and up to ~1.5k if it reads all its reference files. Until then it costs about 56 tokens; SKILL.md has 540 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~56
When it runs · the whole SKILL.md, loaded when a task matches
~1.5k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~1.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from jeremylongshore/tons-of-skills-marketplace at commit cfae287, republished under its MIT licence (© jeremylongshore). 540 words, ~1,530 tokens.

Download SKILL.mdSave it as .claude/skills/running-performance-tests/SKILL.md (or your agent's skills folder). This skill also uses 9 other files; get the full folder from GitHub.
name
running-performance-tests
description
Execute load testing, stress testing, and performance benchmarking. Use when performing specialized testing. Trigger with phrases like "run load tests", "test performance", or "benchmark the system".
allowed-tools
Read, Write, Edit, Grep, Glob, Bash(test:perf-*)
compatibility
Designed for Claude Code
version
1.30.0
author
Jeremy Longshore <jeremy@intentsolutions.io>
license
MIT
tags
testing, performance, performance-tests

Performance Test Suite

Overview

Execute load testing, stress testing, and performance benchmarking to identify bottlenecks, establish baseline metrics, and verify SLA compliance. Supports k6 (recommended), Artillery, Apache JMeter, Locust (Python), and autocannon (Node.js).

Prerequisites

  • Performance testing tool installed (k6, artillery, locust, jmeter, or autocannon)
  • Target application deployed in a production-like environment (not local dev)
  • Baseline performance metrics or SLA targets (e.g., p95 < 200ms, 99.9% availability)
  • Monitoring stack accessible (Grafana, CloudWatch, Datadog) for resource metrics during tests
  • Test data sufficient to avoid cache-only responses

Instructions

  1. Define performance test scenarios based on production traffic patterns:
    • Load test: Simulate expected peak traffic (e.g., 500 concurrent users for 10 minutes).
    • Stress test: Ramp beyond expected capacity to find the breaking point.
    • Spike test: Sudden burst of traffic (0 to 1000 users in 10 seconds).
    • Soak test: Sustained moderate load for extended duration (1-4 hours) to detect memory leaks.
  2. Create test scripts targeting critical endpoints:
    • Identify the top 5-10 most-hit API endpoints from production access logs.
    • Include both read (GET) and write (POST/PUT/DELETE) operations.
    • Simulate realistic user behavior with think time between requests.
    • Use parameterized data to avoid cache-only hits (randomize query parameters, user IDs).
  3. Configure load profiles:
    • Define virtual user (VU) ramp-up stages (e.g., 10 VUs for 1 minute, then 50 VUs for 5 minutes).
    • Set test duration appropriate to the scenario (load: 10-15 min, soak: 1-4 hours).
    • Configure request timeouts matching production settings.
  4. Execute the performance test:
    • Run from a machine with sufficient network bandwidth and CPU.
    • Avoid running from the same host as the application under test.
    • Monitor application metrics (CPU, memory, DB connections) during execution.
  5. Analyze results against SLA thresholds:
    • p50, p90, p95, p99 response times.
    • Requests per second (throughput).
    • Error rate (target: < 0.1% for load test, higher tolerance for stress test).
    • Resource utilization (CPU < 80%, memory < 85% at peak load).
  6. Identify and document bottlenecks:
    • Slow database queries (check slow query logs).
    • CPU-bound operations (profiling data).
    • Memory leaks (growing RSS over soak test).
    • Connection pool exhaustion (database or HTTP client).
  7. Generate a performance report with visualizations and recommendations.
Show full SKILL.md (196 more words)Show less

Output

  • Performance test scripts (k6 .js, Artillery .yml, or Locust .py files)
  • Execution results with response time percentiles, throughput, and error rates
  • Performance report comparing results against SLA thresholds
  • Bottleneck analysis with specific recommendations
  • CI integration configuration for automated performance regression detection

Error Handling

ErrorCauseSolution
Connection reset by peerServer or load balancer dropping connections under loadCheck max connections settings; increase connection pool size; verify keep-alive configuration
Timeouts spike at certain VU countApplication thread pool or database connection pool exhaustedProfile connection usage; increase pool size; add connection queuing; optimize slow queries
Inconsistent results between runsCache warming, garbage collection pauses, or noisy neighbor effectsRun a warm-up phase before measurement; use dedicated test infrastructure; average across 3 runs
Load generator CPU maxed outSingle machine cannot generate sufficient loadDistribute load generation across multiple machines; use cloud-based load generation services
All requests return cached responsesTest data not sufficiently variedRandomize request parameters; use unique IDs per request; disable CDN caching for test environment

Examples

k6 load test script:

javascript
import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 50 },   // Ramp up
    { duration: '5m', target: 50 },   // Sustained load
    { duration: '2m', target: 200 },  // Stress  # HTTP 200 OK
    { duration: '1m', target: 0 },    // Ramp down
  ],
  thresholds: {
    http_req_duration: ['p(95)<200', 'p(99)<500'],  # 500: HTTP 200 OK
    http_req_failed: ['rate<0.01'],
  },
};

export default function () {
  const res = http.get('https://api.test.com/products');
  check(res, {
    'status is 200': (r) => r.status === 200,  # HTTP 200 OK
    'response time OK': (r) => r.timings.duration < 300,  # 300: timeout: 5 minutes
  });
  sleep(1); // Think time
}

Artillery test configuration:

yaml
config:
  target: "https://api.test.com"
  phases:
    - duration: 120
      arrivalRate: 10
      name: "Warm up"
    - duration: 300  # 300: timeout: 5 minutes
      arrivalRate: 50
      name: "Sustained load"
  ensure:
    p95: 200  # HTTP 200 OK
    maxErrorRate: 1
scenarios:
  - flow:
      - get:
          url: "/api/products"
      - think: 1
      - post:
          url: "/api/cart"
          json: { productId: "{{ $randomString() }}" }

Resources

© jeremylongshore, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 9 other files (scripts, references, assets) in skills/.curated/running-performance-tests of jeremylongshore/tons-of-skills-marketplace.

  • SKILL.md
  • assets/README.md
  • assets/example_test_configurations.json
  • assets/report_template.html
  • assets/test_template.js
  • references/README.md
  • scripts/README.md
  • scripts/analyze_results.py
  • scripts/init_test.py
  • scripts/run_test.py

Open the folder on GitHubat commit cfae287

Compare with similar skills

Running Performance Tests next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Running Performance Tests compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Running Performance Tests this skilljeremylongshore/tons-of-skills-marketplace2.8k—~1.5kAutomated safety check: PassMIT
Writing Livekit Scenarioslivekit-examples/agent-starter-python2641 repos~2.5kAutomated safety check: PassMIT
Go Testingcxuu/golang-skills1731 repos~1.3kAutomated safety check: PassApache-2.0
Goalcraftgrp06/goalcraft102—~3.8kAutomated safety check: PassMIT
Thinking Partnermattnowdev/thinking-partner206—~4.4kAutomated safety check: PassMIT
Visionkunchenguid/vision331—~2.9kAutomated safety check: PassMIT

Similar skills

  • Writing Livekit Scenarios

    livekit-examples/agent-starter-python

    Creates and maintains the scenarios a LiveKit agent simulation runs, and wires the agent to consume them.

    264 GitHub starsUsed in 1 repo~2.5k tokens
    Testing & QAAuto-check passed
  • Go Testing

    cxuu/golang-skills

    A skill your agent uses when writing, reviewing, or improving Go test code — including table-driven tests, subtests, parallel tests, test helpers, test doubles, and assertions with cmp.Diff.

    173 GitHub starsUsed in 1 repo~1.3k tokens
    Testing & QAAuto-check passed
  • Goalcraft

    grp06/goalcraft

    Turn a rough draft, vague ambition, or messy task brief into a powerful Codex /goal objective for persistent, evidence-checked work.

    102 GitHub stars~3.8k tokensUpdated 4 mo ago
    Testing & QAAuto-check passed
  • Thinking Partner

    mattnowdev/thinking-partner

    A deterministic thinking partner that challenges assumptions and applies mental models to sharpen decisions, solve problems, and think more clearly.

    206 GitHub stars~4.4k tokensUpdated 6 mo ago
    Testing & QAAuto-check passed
  • Vision

    kunchenguid/vision

    Draft and stress-test a VISION.md for a repository, then iterate with the author on an interactive review board until approved.

    331 GitHub stars~2.9k tokensUpdated 1 mo ago
    Testing & QAAuto-check passed
  • Volt Load Testing

    owenHochwald/volt

    Safely exercise and evaluate HTTP APIs with the Volt CLI, including authenticated requests, JSON bodies, staged load, machine-readable results, performance baselines, and before/after comparisons.

    141 GitHub stars~1.2k tokensUpdated 2 mo ago
    Testing & QAAuto-check passed

More from jeremylongshore/tons-of-skills-marketplace

All 3,342 skills in this repo
  • Performing Security Code Review

    jeremylongshore/tons-of-skills-marketplace

    Execute this skill enables AI assistant to conduct a security-focused code review using the security-agent plugin.

    2.8k GitHub starsUsed in 2 repos~1.3k tokens
    Auto-check: notes
  • Adapting Transfer Learning Models

    jeremylongshore/tons-of-skills-marketplace

    Build this skill automates the adaptation of pre-trained machine learning models using transfer learning techniques.

    2.8k GitHub stars~1.1k tokensUpdated today
    Auto-check passed
  • Agent Context Loader

    jeremylongshore/tons-of-skills-marketplace

    Execute proactive auto-loading: automatically detects and loads agents.md files.

    2.8k GitHub stars~1.1k tokensUpdated today
    Auto-check passed
  • Aggregating Performance Metrics

    jeremylongshore/tons-of-skills-marketplace

    Aggregate and centralize performance metrics from applications, systems, databases, caches, and services.

    2.8k GitHub stars~1.2k tokensUpdated today
    Auto-check passed
  • Analyzing Capacity Planning

    jeremylongshore/tons-of-skills-marketplace

    Execute this skill enables AI assistant to analyze capacity requirements and plan for future growth.

    2.8k GitHub stars~947 tokensUpdated today
    Auto-check passed
  • Analyzing Database Indexes

    jeremylongshore/tons-of-skills-marketplace

    Process use when you need to work with database indexing. An agent skill from jeremylongshore/tons-of-skills-marketplace.

    2.8k GitHub stars~2k tokensUpdated today
    Auto-check passed

Categories

Questions about Running Performance Tests

What does Running Performance Tests do?

Execute load testing, stress testing, and performance benchmarking. Running Performance Tests is an agent skill from jeremylongshore/tons-of-skills-marketplace. Execute load testing, stress testing, and performance benchmarking.

When should I use Running Performance Tests?

Running Performance Tests fits situations like: performing specialized testing; with phrases like run load tests; test performance; benchmark the system.

How do I install Running Performance Tests in Claude Code?

Run `npx skills add jeremylongshore/tons-of-skills-marketplace --skill running-performance-tests -a claude-code`. Or copy the skill folder (skills/.curated/running-performance-tests in jeremylongshore/tons-of-skills-marketplace) into .claude/skills/running-performance-tests in your project. Claude Code loads it when a task matches its description.

How do I install Running Performance Tests in Codex?

Run `npx skills add jeremylongshore/tons-of-skills-marketplace --skill running-performance-tests -a codex`. Or copy the skill folder (skills/.curated/running-performance-tests in jeremylongshore/tons-of-skills-marketplace) into .agents/skills/running-performance-tests in your project. Codex loads it when a task matches its description.

Can I use Running Performance Tests in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add jeremylongshore/tons-of-skills-marketplace --skill running-performance-tests -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/running-performance-tests, .gemini/skills/running-performance-tests, .github/skills/running-performance-tests and .opencode/skills/running-performance-tests in your project.

What does Running Performance Tests need to run?

Going by SKILL.md and its folder, Running Performance Tests needs Python and JavaScript for the scripts in its folder. Our summary lists: Python 3; Node.js. Its frontmatter pre-approves these tools: Read, Write, Edit, Grep, Glob, Bash(test:perf-*). Compatibility (from SKILL.md): Designed for Claude Code.

Does Running Performance Tests access the network?

SKILL.md names 6 domains. In commands or code: api.test.com; the agent is likely to contact it when it follows the instructions. As links in the text: grafana.com, artillery.io, docs.locust.io, jmeter.apache.org and github.com. This is read from the text; nothing was executed.

Is Running Performance Tests safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Running Performance Tests use?

Running Performance Tests is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Running Performance Tests use?

About 1.5k tokens (SKILL.md is roughly 6.1k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 17 tokens, read only when the agent opens those files.

What are the alternatives to Running Performance Tests?

Skills that share tags, products or a category with Running Performance Tests: Writing Livekit Scenarios (livekit-examples/agent-starter-python, 264 stars), Go Testing (cxuu/golang-skills, 173 stars), Goalcraft (grp06/goalcraft, 102 stars) and Thinking Partner (mattnowdev/thinking-partner, 206 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Running Performance Tests?

jeremylongshore (a GitHub user) maintains it in jeremylongshore/tons-of-skills-marketplace, which has 2,827 GitHub stars. The repository holds 3,342 skills in this directory. The repository was last updated on October 10, 2026.

Source: jeremylongshore/tons-of-skills-marketplace on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.