Guide · Agent skill

How to use the Performance Benchmark agent skill (benchmark)

Updated 2026-10-29 · written with AI from the project's own documentation and checked against our catalogue data

The benchmark skill is an agent skill from the ECC project that lets an AI agent measure how fast a web page, an API or a build runs, save those numbers as a baseline, and then compare later runs against it. It is useful for developers who want to catch slowdowns in pull requests and for teams setting performance targets before a launch. After this guide you will know what the skill does, how to install it, how to trigger it with plain requests, and what it needs to run.

Performance Benchmarkaffaan-m/ECC · MIT Download the skill

Quick start

1Download and unzip. Download the skill ZIP from this page and unzip it so the folder contains SKILL.md.
2Place the skill folder. Move it into ~/.claude/skills/ for personal use or into your project's .claude/skills/ folder for one project.
3Confirm requirements. Make sure a browser automation tool (MCP) is available for page metrics, and Git is installed to share baselines.
4Save a baseline. Run /benchmark baseline before you change code to store current metrics as JSON in .ecc/benchmarks/.
5Make your change. Edit code, rebuild or redeploy as needed.
6Compare. Run /benchmark compare to get a Before, After, Delta and Verdict table for each metric.

What is an agent skill and what does benchmark make the agent do?

An agent skill is a folder containing a SKILL.md file that tells an AI agent how to perform a specific task. When the skill is installed, the agent can follow its instructions when a request matches it.

The benchmark skill covers four modes: page performance, API performance, build performance, and before/after comparison. In page mode it uses a browser automation tool (MCP) to measure Core Web Vitals such as LCP, CLS, INP, FCP and TTFB, plus resource sizes and network request counts. In API mode it hits each endpoint 100 times and reports p50, p95 and p99 latency. In build mode it times cold builds, hot reload (HMR), test suites, TypeScript checks, lint and Docker builds.

Page mode: Core Web Vitals, total page weight, JS bundle size, CSS, images, third-party scripts, render-blocking resources
API mode: p50, p95, p99 latency, response size, status codes, and a 10-concurrent-request load test
Build mode: cold build, hot reload, test suite, TypeScript check, lint, Docker build
Compare mode: saves a baseline, then outputs a Before/After/Delta/Verdict table

How do you install the benchmark skill?

Download the ZIP for this skill from the directory page and unzip it. The skill folder contains SKILL.md. Place the folder in ~/.claude/skills/ to make it available to you across projects, or in a project's .claude/skills/ folder to limit it to that project.

You can also upload the skill in the Claude apps by going to Settings → Capabilities → Skills.

Personal install: unzip into ~/.claude/skills/
Project install: unzip into the project's .claude/skills/
Claude apps: Settings → Capabilities → Skills, then upload

How do you trigger the benchmark skill?

You can ask in natural language, for example before a change or when a user reports slowness. The source also documents slash commands for the comparison workflow.

Use /benchmark baseline to save current metrics before you change code, make your changes, then run /benchmark compare to compare against the saved baseline.

"Measure the performance of this page before I change the header."
"Set a performance baseline for our API endpoints."
"Users say the app feels slow. Benchmark the main pages."
"Compare the build time now against the baseline."

/benchmark baseline
# ... make changes ...
/benchmark compare

What does the before/after output look like?

Compare mode produces a table with one row per metric. Each row shows the before value, the after value, the change, and a verdict marking the metric as better or worse. Baselines are saved as JSON in .ecc/benchmarks/, which is tracked by Git so the team can share them.

Metric, Before, After, Delta and Verdict columns
Example verdicts in the source: WARNING: WARN for slower results and ✓ BETTER for improvements

| Metric | Before | After | Delta | Verdict |
|--------|--------|-------|-------|---------|
| LCP | 1.2s | 1.4s | +200ms | WARNING: WARN |
| Bundle | 180KB | 175KB | -5KB | ✓ BETTER |
| Build | 12s | 14s | +2s | WARNING: WARN |

What do you need before running it?

Page metrics need a browser automation tool available as an MCP server. Git is needed to share baseline files with the team. Docker is only needed if you measure Docker build time. The skill runs scripts and uses the network, so review what it will run before using it on sensitive systems.

Browser automation tool (MCP) for page metrics mode
Git, to share baseline files
Docker, only if measuring Docker build time
Optional related skills: /canary-watch and /browser-qa

What safety points should you know about?

The skill sends requests to your endpoints. In API mode it sends 100 requests per endpoint plus 10 concurrent requests. Only run it against live production APIs if you are authorised to load test them. The skill is listed as running scripts and using the network, so check the code and the target before running it.

Do not run API mode against production APIs without authorisation
Check which URLs and endpoints you point it at
Review the scripts it runs, since the skill runs scripts

What tips help you get useful results?

Save a baseline before you start changing code, so the comparison reflects only your change. The source suggests running compare in CI on every pull request, pairing with /canary-watch for monitoring after deploys, and pairing with /browser-qa for a full pre-ship checklist.

Save the baseline on the same branch and machine you will compare on
Run /benchmark compare in CI for every PR
Commit the .ecc/benchmarks/ files so the team shares baselines
Use /canary-watch after deployment and /browser-qa before shipping

What people use it for

Catching a bundle size increase in a pull request before it merges
Setting p95 latency targets for API endpoints before a product launch
Measuring cold build and hot reload time after a build tool change
Comparing a web stack against an alternative using the same metrics

Frequently asked questions

Is the benchmark agent skill free?

The source lists the skill under the MIT licence. Check the licence file in the repository for the full terms before reusing it.

What do I need to install the benchmark skill?

Download the ZIP, unzip it into ~/.claude/skills/ or a project's .claude/skills/, or upload it under Settings → Capabilities → Skills in the Claude apps. Page metrics also need a browser automation tool (MCP).

Do I need a browser tool to use it?

Only for page performance mode. The source says that mode uses a browser MCP to take real browser measurements. API and build modes are described without it.

Can it run against a live production API?

The skill sends 100 requests per endpoint plus 10 concurrent requests in API mode. Only run it against live APIs where load testing is authorised.

Where are the benchmark results saved?

Baselines are saved as JSON in .ecc/benchmarks/. Because Git tracks that folder, the team can share the baselines.

How does it compare with other performance tools?

The source does not compare it with other tools. It is aimed at agent-driven before/after checks during development, and it assumes familiarity with metrics like p95 latency and LCP. For a quick page speed score without that background, a simpler page speed tool may suit you better.

New agent skills, repos and AI tools — every week

The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.

Our verdict

Choose the benchmark skill if you are a developer or team who wants before-and-after performance checks in your workflow, especially in pull requests. Skip it if you only need a quick page speed score, or if you cannot authorise load tests against your APIs.

Download the skill