Skip to main content
skill CX Codex

performance-engineering — Claude Code skill: setup and usage

performance-engineering — a skill for Claude Code designed for full-stack web application performance optimization. Activates when Core Web Vitals drop, bundle sizes increase, or page response times degrade.

MIT 144 installs ★ 114 updated 2026-11-10

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add travisjneuman/.claude --skill performance-engineering -a claude-code
Open on GitHub

What performance-engineering does

This skill guides optimization work across Core Web Vitals (LCP, INP, CLS), bundle splitting, image assets, and caching headers. It enforces a measurement-driven workflow requiring profiling through RUM, Lighthouse, or DevTools before writing any optimization code.

Included guidelines define strict budgets: JavaScript bundles under 200kb, LCP under 2.5s, INP under 200ms, and CLS under 0.1. Load analysis relies on k6 and Artillery, though load tests execute strictly on explicit request.

Reference material sits in standalone files inside the references folder, detailing caching patterns with immutable hashes, stale-while-revalidate strategies, anti-patterns, and review checklists.

What it helps with

  • set performance budgets for bundle size and Core Web Vitals
  • analyze and split oversized JavaScript bundles
  • configure browser and CDN caching headers
  • generate load testing scripts with k6 or Artillery

Example prompts for the agent

  • Inspect our client bundle and suggest code splitting to meet a 200kb budget
  • Set up caching headers for static assets and dynamic endpoints using stale-while-revalidate
  • Create a k6 load test script for our checkout API flow

How to install performance-engineering

1Skills CLI (Vercel)

npx skills add travisjneuman/.claude --skill performance-engineering -a claude-code

2Manually: put the files in place

~/.claude/skills/performance-engineering/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/performance-engineering/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about performance-engineering

How to install performance-engineering in Claude Code?

Run npx skills add travisjneuman/.claude --skill performance-engineering -a claude-code in your terminal.

What does performance-engineering do?

It provides guidelines and performance budgets for Core Web Vitals, bundle reduction, CDN caching, and load testing.

What tools are needed for performance-engineering?

It uses profiling inputs from Lighthouse, DevTools, or RUM, and requires k6 or Artillery when executing load tests.

Source text

SKILL.md · MIT
---
name: performance-engineering
description: Web Vitals, bundle optimization, CDN, caching, and load analysis. Use when diagnosing slow pages or APIs, reducing bundle size, or designing caching and performance budgets.
---

# Performance Engineering

## Overview

This skill covers measuring, optimizing, and maintaining web application performance across the full stack. It addresses Core Web Vitals (LCP, INP, CLS), bundle analysis and code splitting, image optimization, browser and server-side caching, CDN configuration, database query performance, and load testing with k6 and Artillery.

Use this skill when Core Web Vitals scores are below targets, bundle sizes are growing, page load times are degrading, or when preparing for traffic spikes. Performance work should be measurement-driven: profile first, optimize second, measure the impact third.

---

## Core Principles

1. **Measure before optimizing** - Profile with real data (RUM, Lighthouse, DevTools) before writing any optimization code. Intuition about performance bottlenecks is usually wrong.
2. **Budget everything** - Set performance budgets for bundle size (< 200kb JS), LCP (< 2.5s), INP (< 200ms), CLS (< 0.1). Check changes against them in review.
3. **Optimize the critical path** - Focus on what blocks the user from seeing and interacting with content. Everything else can load later.
4. **Cache aggressively, invalidate precisely** - Use immutable hashes for static assets, short TTLs for dynamic content, and stale-while-revalidate for the best of both worlds.
5. **Reason at realistic scale** - Judge designs against production-like data volumes and traffic, not toy datasets with 10 concurrent users; run load tests only when the user asks for them.

---

## Reference files

Detailed material is in separate files so this overview stays short. Read only the file whose topic matches the task; each one is self-contained. Paths are relative to the folder that holds this `SKILL.md` (in the full toolkit install, `~/.claude/skills/performance-engineering/`).

| Topic | File | Covers |
| --- | --- | --- |
| Key Patterns | [`references/key-patterns.md`](references/key-patterns.md) | Pattern 1: Core Web Vitals Monitoring; Pattern 2: Bundle Optimization and Code Splitting; Pattern 3: Image Optimization; Pattern 4: Caching Strategy; Pattern 5: Load Testing with k6 |
| Performance Budget Reference | [`references/performance-budget-reference.md`](references/performance-budget-reference.md) | 14 lines |
| Anti-Patterns | [`references/anti-patterns.md`](references/anti-patterns.md) | 14 lines |
| Checklist | [`references/checklist.md`](references/checklist.md) | 16 lines |

## Related Resources

- **Skills:** `monitoring-observability` (performance monitoring), `serverless-development` (cold start optimization)
- **Rules:** `docs/reference/checklists/ui-visual-changes.md` (visual performance)
- **Rules:** `docs/reference/stacks/react-typescript.md` (React performance patterns)

© travisjneuman · MIT · travisjneuman/.claude

Similar skills

All skills for Frontend and UI →

From the same set117

The whole set →
impact-report-writer The impact-report-writer skill helps structure program impact reports, choose outcome metrics, and plan data visualizations. Use it for annual reports or program evaluations. CX Codex +1 145installs frontend-enhancer frontend-enhancer polishes the visual side of a web app: palette, layout, motion, component states. Useful when the UI still reads as a stock starter. CX Codex +1 145installs status-report-generator The status-report-generator Claude Code skill builds project status reports from Git activity, task context, and milestone tracking. It can create weekly updates, sprint reviews, and stakeholder reports. CX Codex +1 145installs generic-ux-designer generic-ux-designer — a UX skill for Claude and other coding agents: design-thinking steps, heuristic review and accessibility checks, packaged as checklists the agent follows. CX Codex +1 145installs authentication-patterns authentication-patterns — a Claude Code skill for authentication and authorization patterns. It comes into play when building login flows, MFA, SSO, or access-control models. CX Codex +1 144installs i18n-localization The i18n-localization Claude Code skill guides internationalization and localization work. It activates for translation setup, locale-specific formatting, and adapting an app for multiple regions. CX Codex +1 143installs vue-development vue-development — a Claude Code skill for building Vue 3 applications with the Composition API and Script Setup. Guides state setup in Pinia, custom composables, and Nuxt 3 full-stack tasks. CX Codex +1 143installs generic-design-system generic-design-system provides standard design system guidelines for AI coding agents, covering color tokens, typography, spacing scales, and component states. CX Codex +1 143installs

Project sponsors

Companies that keep this analytics open