Turn your AI assistant into a senior performance engineer with perf-skills

In performance testing, having a senior teammate around changes everything. They spot the missing assertions in your script, add just enough think time to mirror real user behavior, and never fumble correlation. That judgment used to take years to build. Large language model coding assistants promise to shortcut the rote parts, but out of the box they write junior-level performance scripts: zero think time, missing assertions, and syntactically valid code that falls over on dynamic values. perf-skills is an open-source, token-optimized knowledge base built to fix exactly that gap, turning a generic assistant into something much closer to a senior performance engineer.

Why generic assistants write junior performance scripts

The failure pattern is consistent. Ask an AI assistant for a JMeter or k6 script and you get something that looks right: requests in order, plausible syntax, a few timers sprinkled in. Then you run it and the problems surface. There is no think time between requests, so virtual users hammer the server at a pace no human matches. Assertions are generic or absent, so the test passes while the application returns error pages. And correlation, the extraction of dynamic values like CSRF tokens and session IDs and their reuse across the scenario, is simply missing. The script logs in once and replays a dead token for the rest of the run.

The instinctive fix makes things worse. Paste the tool manual into the prompt and the context window bloats, responses slow down, and token costs climb, while the model still misses the judgment calls that matter. As the perf-skills author puts it, dumping documentation on the model confuses it and costs a fortune in tokens. The problem is not missing information. It is missing curation.

What perf-skills actually is

perf-skills is a highly structured, opinionated knowledge base designed for injection into LLM-based coding assistants, and its defining choice is selective loading. Instead of one giant reference, it uses a routing system that starts from a single entry point: the assistant always reads a SKILL.md file first, which holds global rules such as think time matters and assertions are not optional, and routes the request to only the files that apply. Ask for a k6 script and it loads the k6 material. Ask about correlating a session token in JMeter and it loads the JMeter plus correlation modules, typically just one or two files per request. That keeps prompts small, responses fast, and output accurate, which is what makes the approach cost-viable in tight context windows.

The honest framing from the source is that perf-skills acts as an on-demand brain transplant: deep, expert-level performance testing context injected exactly when the assistant needs it. If your team already invests in making repositories legible to agents, the same thinking applies, see our notes on agent-readable repository structure. The knowledge base covers scripting rules, debugging patterns, and tool-specific pitfalls rather than generic advice.

Which tools and protocols it covers

Breadth is where perf-skills earns its keep, because performance estates are rarely single-tool. On the open-source side it covers Apache JMeter, k6, Gatling, and Locust. On the commercial side it covers NeoLoad, LoadRunner, and OctoPerf. Protocol coverage includes HTTP/REST, gRPC, GraphQL, WebSocket, SSE, JDBC, SOAP, Kafka and MQ, plus enterprise protocols such as Citrix and SAP. That range matters in practice: the same assistant can generate a k6 script for an HTTP API in the morning and help debug a LoadRunner scenario against a legacy backend in the afternoon, with tool-specific guidance loaded per task rather than averaged across all of them.

The tool-specific angle is the difference between a script that parses and a script that works. Generic models overfit to the most common syntax and produce output that is syntactically valid but practically broken, such as JMeter sampler configurations that ignore scoping rules or k6 data-loading patterns that defeat the very load profile being tested. perf-skills pulls in context-aware advice per tool so those traps are addressed before the script is written, not discovered during the post-mortem.

How correlation stops being the hard part

Correlation is widely considered the most painful part of performance scripting, and it gets a dedicated module. The knowledge base enumerates extraction tactics per protocol and response type: JSONPath for JSON responses, CSS selectors for HTML, and regex only as a last resort. That ordering encodes senior judgment directly. Regex-first correlation is the classic junior mistake, brittle against the smallest markup change, and the module steers the assistant away from it by default.

The module also covers the surrounding discipline that makes correlation hold up under load: extracting CSRF tokens and session IDs per virtual user rather than once globally, propagating them through the whole scenario, and pairing them with assertions that actually verify application state instead of HTTP 200 alone. For background workloads that need the same rigor, the patterns complement what we describe in AI production background jobs. When a login step fails one run in ten, the debugging guidance points at exactly which samplers to log and which bottlenecks to check for the tool in use, instead of leaving the assistant to guess.

Which assistants it plugs into

perf-skills integrates with Claude Code, Cursor, Windsurf, and Devin, with setup paths documented per assistant and Claude Code as the recommended starting point. Any assistant that accepts injected context benefits; for closed tools without a context API the value is diminished, though that constraint loosens as vendors open up. If you use Cursor specifically, our Cursor prompts for agent sessions guide pairs well with the skill-based approach here: prompts set the intent, perf-skills supplies the domain judgment.

// Pseudocode: loading only the relevant perf-skills slice
const perfSkillsContext = loadPerfSkills('k6', ['http', 'correlation', 'thinkTime'])
aiAssistant.runCodeCompletion({
  context: perfSkillsContext,
  prompt: 'Write a k6 script for login plus queue-status polling.',
})

A typical workflow looks like this. First, pick the task and the tool. Second, load only the relevant modules, for example just the correlation module for a JMeter CSRF problem. Third, inject that slice as context into the assistant. Fourth, run the generated script and validate: sleeps should reflect real user pacing, extractors should match response types, and assertion blocks should cover status, payload content, and at least one latency signal. Fifth, when something fails, rerun with the debugging context scoped to the failing tool rather than the whole knowledge base.

# Scoping context to one module keeps token spend flat
export PERF_KB=$(cat correlation_kb.md)
ai-coding-assistant --context "$PERF_KB" --task "Write a JMeter script handling CSRF and session cookie."

What it does not promise

Two caveats keep this honest. First, there are no published numerical benchmarks for perf-skills output quality; per the source author, the evidence so far is user feedback around improved script correctness and reduced flakiness, not measured studies. Treat claims of observably better output as the author's report, not an independent finding. Second, a knowledge base cannot fix a broken performance strategy. If nobody has decided what the load profile represents, which endpoints are in scope, or what latency budget counts as passing, the assistant will generate confident scripts against undefined goals. perf-skills upgrades the how, not the what.

Closing

Turnkey AI performance testing was a mirage while the choice was between a junior-level default and a firehose of pasted manuals. A context-optimized knowledge base like perf-skills offers a third option: targeted, expert guidance loaded one slice at a time, so the assistant writes scripts with think time, real assertions, and working correlation from the first draft. The pattern generalizes beyond performance work. Wherever expertise is scarce and context is expensive, a small curated skill file beats a large generic prompt. Plug in the skill, keep the human owning the strategy, and move past junior-AI speed bumps for good.

Ship the app the tests are protecting with templates your agent can deploy: OTF templates.

Sources

• Turn your AI assistant into a senior performance engineer: introducing perf-skills — perf-skills design, SKILL.md routing, supported tools and protocols, supported assistants, correlation module.
• Turn your AI assistant into a senior performance engineer: introducing perf-skills — full tool and protocol support matrix.
• Turn your AI assistant into a senior performance engineer: introducing perf-skills — selective loading mechanism and token rationale.