benchmark

Use it when:: You want a PR's performance impact, baselines before a launch, or numbers behind an "it feels slow" report.
It does:: Measures LCP, CLS, INP and page weight in a browser, p50 to p99 latency over 100 calls per endpoint, and build, test and lint times.
You get:: A before-and-after table with deltas and verdicts, and baselines saved as JSON in .ecc/benchmarks/ for the team to commit.
Needs:: A browser MCP server for the page measurements.

Page measurements need a browser MCP server. API mode calls each endpoint 100 times, then at 10 concurrent requests.

TL;DR

ECC's benchmark skill has four modes. Page performance navigates to each URL through a browser MCP server and measures Core Web Vitals against targets: LCP under 2.5s, CLS under 0.1, INP under 200ms, FCP under 1.8s and TTFB under 800ms. It also weighs the page, its JavaScript, CSS, images and third-party scripts, counts requests and flags render-blocking resources. API performance calls each endpoint 100 times for p50, p95 and p99 latency, response size and status codes, then tests 10 concurrent requests and compares with your SLA targets. Build performance times cold builds, hot reload, the test suite, type checking, lint and Docker builds. Comparison mode saves a baseline, then after your change reports each metric's delta with a better or warning verdict. Baselines go in .ecc/benchmarks/ as git-tracked JSON so a team shares them, and it suggests running the comparison on every PR in CI.

Summarizes the skill at d2ef268.

npx skills add https://github.com/affaan-m/ecc --skill benchmark

skills.sh page Source on GitHub All skills from affaan-m/ecc

Total Downloads: 5,400 on skills.sh, Nov 9, 2026
Repo stars: 299,776 affaan-m/ecc
First seen: May 19, 2026 on skills.sh

Weekly Downloads

446

+72% over the 8 weeks to Nov 9

Weekly values

Week to	Installs
Sep 21	259
Sep 28	156
Oct 5	142
Oct 12	234
Oct 19	412
Oct 26	407
Nov 2	478
Nov 9	446

Category	category:debugging category:software-engineering Find root causes, review code and test what you built. Everything for building software: planning, coding, debugging, design, frameworks, cloud, agents and skills.
Type	type:workflow A multi-step process the agent follows: interview, debug, run a TDD loop, review.
Effect	effect:local Its own steps create or change files, git state or local tools.
Needs	needs:mcp needs:browser Needs an MCP server connected. Drives a real Chromium or Chrome browser.
Publisher	by:community Everyone else. Unverified vendor claims default to community.
Topics	performance testing ci

SKILL.md

From affaan-m/ecc at d2ef268. Checked daily, last changed Nov 6, 2026.

Frontmatter

name: benchmark
description: Measure performance baselines and detect regressions across browser Core Web Vitals (LCP, INP, CLS, page weight), API endpoint latency percentiles, and build/test feedback times, with before/after comparison stored in git-tracked .ecc/benchmarks JSON. Use when checking page speed, responding to 'it feels slow' reports, verifying launch performance targets, or comparing stack alternatives.
license: MIT
metadata:
  origin: ECC

Benchmark — Performance Baseline & Regression Detection

When to Use

Before and after a PR to measure performance impact
Setting up performance baselines for a project
When users report "it feels slow"
Before a launch — ensure you meet performance targets
Comparing your stack against alternatives

How It Works

Mode 1: Page Performance

Measures real browser metrics via browser MCP:

1. Navigate to each target URL
2. Measure Core Web Vitals:
   - LCP (Largest Contentful Paint) — target < 2.5s
   - CLS (Cumulative Layout Shift) — target < 0.1
   - INP (Interaction to Next Paint) — target < 200ms
   - FCP (First Contentful Paint) — target < 1.8s
   - TTFB (Time to First Byte) — target < 800ms
3. Measure resource sizes:
   - Total page weight (target < 1MB)
   - JS bundle size (target < 200KB gzipped)
   - CSS size
   - Image weight
   - Third-party script weight
4. Count network requests
5. Check for render-blocking resources

Mode 2: API Performance

Benchmarks API endpoints:

1. Hit each endpoint 100 times
2. Measure: p50, p95, p99 latency
3. Track: response size, status codes
4. Test under load: 10 concurrent requests
5. Compare against SLA targets

Mode 3: Build Performance

Measures development feedback loop:

1. Cold build time
2. Hot reload time (HMR)
3. Test suite duration
4. TypeScript check time
5. Lint time
6. Docker build time

Mode 4: Before/After Comparison

Run before and after a change to measure impact:

/benchmark baseline    # saves current metrics
# ... make changes ...
/benchmark compare     # compares against baseline

Output:

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

Output

Stores baselines in .ecc/benchmarks/ as JSON. Git-tracked so the team shares baselines.

Integration

CI: run /benchmark compare on every PR
Pair with /canary-watch for post-deploy monitoring
Pair with /browser-qa for full pre-ship checklist