Measure Performance Baselines
Your AI measures web page, API, and build performance before and after changes. It collects browser metrics, API latency, and build times to detect regressions and compare technology stacks.
affaan-m on GitHub
Curated by PromptsEdge from a public repo · MIT license. All credit goes to the author.
What is this skill?
Use this skill to measure performance baselines, detect regressions before/after PRs, and compare stack alternatives.
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
What’s inside
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 compareon every PR - Pair with
/canary-watchfor post-deploy monitoring - Pair with
/browser-qafor full pre-ship checklist
Install this skill
- 1
Get the skill — it’s free
Use the Get this skill panel. Unlocked skills stay in My skills. - 2
Download or clone the files
Download the zip, or clone the repo and copy theskills/benchmarkfolder. - 3
Put it where your agent looks for skills
For Claude Code, use your personal skills folder (every project) or a project’s own folder:~/.claude/skills/benchmark/SKILL.md # all projects .claude/skills/benchmark/SKILL.md # this project only
- 4
Just ask
No command needed. The agent reads the skill’s description and loads it on its own when your request matches.
SKILL.md frontmatter
What your agent reads to decide when to load this skill.
--- name: benchmark description: Use this skill to measure performance baselines, detect regressions before/after PRs, and compare stack alternatives. ---
Files
Open any Markdown file to read it here.
Related skills
View all →- Configure and Optimize ViteFreeYour AI configures Vite projects including plugins, environment variables, proxy setup, and build optimization. It handles dev server, SSR, library mode, and troubleshooting common Vite issues.
- Edit and Structure VideoFreeYour AI edits and structures existing video footage into polished content. It manages cutting, overlays, subtitles, voiceovers, and reframing using FFmpeg, Remotion, ElevenLabs, Descript, and CapCut workflows.
- Team Agent OrchestrationFreeYour AI coordinates multiple agents as a team using work items, ownership, Kanban states, and merge gates. It manages shared workflow visibility, branch isolation, and control pane handoffs for multi-agent project collaboration.
- Taste-Based Video ApplicationFreeYour AI generates videos applying a distilled style pack, planning cuts by measured rhythm and grading with LUTs. It weaves generated and existing footage into finished edits with overlays and 3D props, verifying results numerically.