Catalog
affaan-m/benchmark

affaan-m

benchmark

Use this skill to measure performance baselines, detect regressions before/after PRs, and compare stack alternatives.

NewUpdated Sep 9, 2026

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
Files1
1 files · 1.0 KB

Select a file to preview

Overall Score

76/100

Grade

B

Good

Grades are signals, not a certification. Always review a skill yourself before use.

Safety

92

Quality

72

Clarity

82

Completeness

65

Summary

This skill guides AI agents to measure web application performance across four dimensions: page performance (Core Web Vitals, resource sizes, network metrics), API endpoint latency, build system speed, and before/after regression detection. It stores baselines in a `.ecc/benchmarks/` directory and supports comparative analysis to identify performance regressions introduced by code changes.

Detected Capabilities

metric collection via browser MCPAPI endpoint testing under loadbuild system performance measurementfile write to .ecc/benchmarks/ directoryJSON baseline storagecomparative analysis and delta calculation

Trigger Keywords

Phrases that agents use to match this skill to user intent.

measure performance baselinedetect performance regressioncore web vitalscompare build timesapi latency benchmarkbefore after comparison

Use Cases

  • Measure performance impact of pull requests before merging
  • Establish performance baselines for regression detection in CI/CD pipelines
  • Diagnose user-reported slowness by capturing Core Web Vitals and resource metrics
  • Compare performance across different technology stacks or implementations
  • Monitor build and development feedback loop performance (cold builds, HMR, tests, TypeScript checks)
  • Validate performance targets before product launches

Quality Notes

  • Strength: Four distinct benchmarking modes are clearly documented with specific metrics and targets (e.g., LCP < 2.5s, bundle < 200KB gzipped).
  • Strength: Clear output format shown with concrete example table demonstrating before/after deltas and verdict indicators.
  • Strength: Integration points documented (CI workflows, pairing with canary-watch and browser-qa skills).
  • Strength: Safe operations — all capability calls are read-only or scoped to dedicated `.ecc/` directory; no shell execution, credential access, or destructive operations.
  • Limitation: No error handling guidance provided. What should the agent do if an endpoint times out, or if Core Web Vitals fail to capture?
  • Limitation: Baseline storage location (`.ecc/benchmarks/`) is mentioned but edge cases are not covered — what if the directory doesn't exist? How are baselines versioned or retained over time?
  • Limitation: No guidance on statistical significance or variance handling — should single measurements be trusted, or should multiple runs be performed?
  • Limitation: Load test parameters (100 hits, 10 concurrent requests) are hardcoded; no explanation of how to adjust for different API SLAs or environments.
  • Missing: No mention of how to handle environments with different characteristics (local dev vs. staging vs. production) — performance targets may need adjustment.
  • Missing: No guidance on handling flaky metrics or outlier detection in high-variance measurements.
Model: claude-haiku-4-5-20251001Analyzed: Sep 9, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Version History

  1. v1.3

    Content updated

    ✦ AIAdds MIT license declaration.

    license2026-09-09

    LATEST
  2. v1.2

    Content updated

    ✦ AINo behavioral changes detected.

    2026-07-14

    View This Version
  3. v1.1

    Content updated

    ✦ AIAdds LICENSE file.

    2026-04-20

    View This Version
  4. v1.0

    2026-04-12

    View This VersionInitial version

Use affaan-m/benchmark in your dev environment

Command Palette

Search for a command to run...