Agent skill

Performance

by yonatangross in yonatangross/orchestkit

Performance optimization patterns covering Core Web Vitals, React render optimization, lazy loading, image optimization, backend profiling, LLM inference, and sustainability UX.

MITAuto-check passedFrontend & Design

Install Performance

skills CLI

$ npx skills add yonatangross/orchestkit --skill performance -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI

$ gh skill install yonatangross/orchestkit performance --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy

$ git clone --depth 1 https://github.com/yonatangross/orchestkit.git skills-src && mkdir -p .claude/skills && cp -r skills-src/src/skills/performance .claude/skills/performance && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Paste into Claude Code

Install the "performance" agent skill from https://github.com/yonatangross/orchestkit/tree/main/src/skills/performance into .claude/skills/performance/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "performance", then confirm the skill loads.

Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

$skill-installer

$skill-installer install https://github.com/yonatangross/orchestkit/tree/main/src/skills/performance

Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.

skills CLI

$ npx skills add yonatangross/orchestkit --skill performance -a codex

Project install goes to .agents/skills/; add -g for ~/.codex/skills/.

GitHub CLI

$ gh skill install yonatangross/orchestkit performance --agent codex

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/yonatangross/orchestkit.git skills-src && mkdir -p .agents/skills && cp -r skills-src/src/skills/performance .agents/skills/performance && rm -rf skills-src

Use ~/.agents/skills/ instead of .agents/skills for a personal install.

Codex skills documentation · loads skills from .agents/skills/

Paste into Codex

Install the "performance" agent skill from https://github.com/yonatangross/orchestkit/tree/main/src/skills/performance into .agents/skills/performance/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "performance", then confirm the skill loads.

Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add yonatangross/orchestkit --skill performance -a cursor

Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.

GitHub CLI

$ gh skill install yonatangross/orchestkit performance --agent cursor

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/yonatangross/orchestkit.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/src/skills/performance .cursor/skills/performance && rm -rf skills-src

Use ~/.cursor/skills/ instead of .cursor/skills for a personal install.

Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/

Paste into Cursor

Install the "performance" agent skill from https://github.com/yonatangross/orchestkit/tree/main/src/skills/performance into .cursor/skills/performance/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "performance", then confirm the skill loads.

Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

gemini skills install

$ gemini skills install https://github.com/yonatangross/orchestkit.git --path src/skills/performance

--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.

skills CLI

$ npx skills add yonatangross/orchestkit --skill performance -a gemini-cli

Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.

GitHub CLI

$ gh skill install yonatangross/orchestkit performance --agent gemini-cli

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/yonatangross/orchestkit.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/src/skills/performance .gemini/skills/performance && rm -rf skills-src

Use ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.

Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/

Paste into Gemini CLI

Install the "performance" agent skill from https://github.com/yonatangross/orchestkit/tree/main/src/skills/performance into .gemini/skills/performance/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "performance", then confirm the skill loads.

Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

GitHub CLI

$ gh skill install yonatangross/orchestkit performance

Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).

skills CLI

$ npx skills add yonatangross/orchestkit --skill performance -a github-copilot

Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.

Manual copy

$ git clone --depth 1 https://github.com/yonatangross/orchestkit.git skills-src && mkdir -p .github/skills && cp -r skills-src/src/skills/performance .github/skills/performance && rm -rf skills-src

Use ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.

GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/

Paste into GitHub Copilot

Install the "performance" agent skill from https://github.com/yonatangross/orchestkit/tree/main/src/skills/performance into .github/skills/performance/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "performance", then confirm the skill loads.

GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add yonatangross/orchestkit --skill performance -a opencode

OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.

GitHub CLI

$ gh skill install yonatangross/orchestkit performance --agent opencode

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/yonatangross/orchestkit.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/src/skills/performance .opencode/skills/performance && rm -rf skills-src

Use ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.

OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/

Paste into OpenCode

Install the "performance" agent skill from https://github.com/yonatangross/orchestkit/tree/main/src/skills/performance into .opencode/skills/performance/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "performance", then confirm the skill loads.

OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

Facts

Skill name: performance
GitHub stars: 289
Token cost: ~3.5k tokens
SKILL.md length: 1,164 words
Files: 45 (incl. scripts, references)
Skills in repo: 108
Repo updated: Oct 7, 2026
First seen: Oct 7, 2026
Licence: MIT

At a glance

Performance optimization patterns covering Core Web Vitals, React render optimization, lazy loading, image optimization, backend profiling, LLM inference, and sustainability UX.

Works in 10 steps: Client-side fetching LCP content (delays… → Images without explicit dimensions… → Lazy loading LCP images (delays largest… → …
Improving page speed
SKILL.md covers Quick Reference, Core Web Vitals, Render Optimization and Lazy Loading, plus 13 more sections
Calls npx and npm

What it does

Performance is an agent skill from yonatangross/orchestkit. Performance optimization patterns covering Core Web Vitals, React render optimization, lazy loading, image optimization, backend profiling, LLM inference, and sustainability UX. Use when improving page speed, debugging slow renders, optimizing bundles, reducing image payload, profiling backend, deploying LLMs efficiently, or reducing digital carbon footprint.

Its SKILL.md is about 3.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 47 other files, including scripts and reference files (for example `examples/orchestkit-performance-wins.md`, `metadata.json` and `references/cc-prompt-cache-guide.md`). Compatibility notes: Claude Code 2.1.277+.

It sits in Frontend & Design, covering Web performance and LLM inference and serving. It works with React. The repository describes itself as: The Complete AI Development Toolkit for Claude Code. 106 skills, 36 agents, 171 hooks. Install ork for stable (v9.x), or ork-alpha for the v10 line, which ships daily. The licence is MIT.

When your agent uses it

Improving page speed
Debugging slow renders
Optimizing bundles
Reducing image payload

Example prompts

“/performance”

Requirements

Node.js
Compatibility (from SKILL.md): Claude Code 2.1.277+.
Pre-approved tools (allowed-tools): Read, Glob, Grep, WebFetch, WebSearch

Workflow steps

10 steps, taken from the first numbered list in SKILL.md.

Client-side fetching LCP content (delays render)
Images without explicit dimensions (causes CLS)
Lazy loading LCP images (delays largest paint)
Heavy computation in event handlers (blocks INP)
Layout-shifting animations (use transform instead)
Lazy loading tiny components < 5KB (overhead > savings)
Missing error boundaries on lazy components
Using GPTQ without calibration data
Not benchmarking actual workload patterns
Only measuring in lab environment (need RUM)

What it can do on your machine

Read from SKILL.md and the folder at commit 0ef71d2. It shows what the files ask for, not the result of running them.

Tool permissions
Pre-approves these tools, so the agent can use them without asking each time:
- Read
- Glob
- Grep
- WebFetch
- WebSearch
From allowed-tools in the SKILL.md frontmatter.
Runs code
Ships 1 file in scripts/, which the agent can run.
Shell commands in SKILL.md call:
- npx
- npm
From the folder's file list and the shell code blocks in SKILL.md.
Network
Links to these hosts (documentation or services it may open):
- web.dev
- github.com
- react.dev
- nextjs.org
- tanstack.com
- reactrouter.com
- vite.dev
- redis.io
- docs.vllm.ai
- developer.chrome.com
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Compatibility
Claude Code 2.1.277+.
From compatibility in the SKILL.md frontmatter.

Context cost

Performance loads about 3.5k tokens when it runs, and up to ~5.5k if it reads all its reference files. Until then it costs about 93 tokens; SKILL.md has 1,164 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it: ~93
When it runs · the whole SKILL.md, loaded when a task matches: ~3.5k
With references · SKILL.md plus every file in references/, read only if the agent opens them: ~5.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from yonatangross/orchestkit at commit 0ef71d2, republished under its MIT licence (© yonatangross). 1,164 words, ~3,460 tokens.

Download SKILL.mdSave it as .claude/skills/performance/SKILL.md (or your agent's skills folder). This skill also uses 44 other files; get the full folder from GitHub.

name: performance
description: Performance optimization patterns covering Core Web Vitals, React render optimization, lazy loading, image optimization, backend profiling, LLM inference, and sustainability UX. Use when improving page speed, debugging slow renders, optimizing bundles, reducing image payload, profiling backend, deploying LLMs efficiently, or reducing digital carbon footprint.
allowed-tools: Read, Glob, Grep, WebFetch, WebSearch
compatibility: Claude Code 2.1.277+.
license: MIT
user-invocable: false
disable-model-invocation: false
effort: high
metadata.owner-agent: frontend-performance-engineer
metadata.category: document-asset-creation
metadata.version: 2.1.0
metadata.author: OrchestKit
metadata.complexity: high
metadata.tags: performance, core-web-vitals, lcp, inp, cls, react-compiler, virtualization, lazy-loading, code-splitting, image-optimization, avif, profiling, vllm…

Performance

Comprehensive performance optimization patterns for frontend, backend, and LLM inference.

Quick Reference

Category	Rules	Impact	When to Use
Core Web Vitals	4	CRITICAL	LCP, INP, CLS optimization with 2026 thresholds
Render Optimization	3	HIGH	React Compiler, memoization, virtualization
Lazy Loading	3	HIGH	Code splitting, route splitting, preloading
Image Optimization	2	HIGH	AVIF/WebP formats, responsive images
Profiling & Backend	3	MEDIUM	React DevTools, py-spy, bundle analysis
LLM Inference	3	MEDIUM	vLLM, quantization, speculative decoding
Caching	2	HIGH	Redis cache-aside, prompt caching, HTTP cache headers
Query & Data Fetching	2	HIGH	TanStack Query prefetching, optimistic updates, rollback
Sustainability	1	MEDIUM	Page weight budgets, lazy loading, optimized formats, dark mode

Total: 23 rules across 9 categories

Core Web Vitals

Google's Core Web Vitals with 2026 stricter thresholds.

Rule	File	Key Pattern
LCP Optimization	`rules/cwv-lcp.md`	Preload hero, SSR, fetchpriority="high"
INP Optimization	`rules/cwv-inp.md`	scheduler.yield, useTransition, requestIdleCallback
INP Advanced	`rules/cwv-inp-advanced.md`	Layout thrashing, third-party scripts, rAF patterns
CLS Prevention	`rules/cwv-cls.md`	Explicit dimensions, aspect-ratio, font-display

2026 Thresholds

Metric	Current Good	2026 Good
LCP	<= 2.5s	<= 2.0s
INP	<= 200ms	<= 150ms
CLS	<= 0.1	<= 0.08

Render Optimization

React render performance patterns for React 19+.

Rule	File	Key Pattern
React Compiler	`rules/render-compiler.md`	Auto-memoization, "Memo" badge verification
Manual Memoization	`rules/render-memo.md`	useMemo/useCallback escape hatches, state colocation
Virtualization	`rules/render-virtual.md`	TanStack Virtual for 100+ item lists

Lazy Loading

Code splitting and lazy loading with React.lazy and Suspense.

Rule	File	Key Pattern
React.lazy + Suspense	`rules/loading-lazy.md`	Component lazy loading, error boundaries
Route Splitting	`rules/loading-splitting.md`	React Router 7.x, Vite manual chunks
Preloading	`rules/loading-preload.md`	Prefetch on hover, modulepreload hints

Image Optimization

Production image optimization for modern web applications.

Rule	File	Key Pattern
Format Selection	`rules/images-formats.md`	AVIF/WebP, quality 75-85, picture element
Responsive Images	`rules/images-responsive.md`	sizes prop, art direction, CDN loaders

Next.js Image component usage and the v16 image config defaults are first-party territory; see "Upstream coverage (do not restate)" below.

Profiling & Backend

Profiling tools and backend optimization patterns.

Rule	File	Key Pattern
React Profiling	`rules/profiling-react.md`	DevTools Profiler, flamegraph, render counts
Backend Profiling	`rules/profiling-backend.md`	py-spy, cProfile, memory_profiler, flame graphs
Bundle Analysis	`rules/profiling-bundle.md`	vite-bundle-visualizer, tree shaking, performance budgets

LLM Inference

High-performance LLM inference with vLLM, quantization, and speculative decoding.

Rule	File	Key Pattern
vLLM Deployment	`rules/inference-vllm.md`	PagedAttention, continuous batching, tensor parallelism
Quantization	`rules/inference-quantization.md`	AWQ, GPTQ, FP8, INT8 method selection
Speculative Decoding	`rules/inference-speculative.md`	N-gram, draft model, 1.5-2.5x throughput

Caching

Backend Redis caching and LLM prompt caching for cost savings and performance.

Rule	File	Key Pattern
Redis & Backend	`rules/caching-redis.md`	Cache-aside, write-through, invalidation, stampede prevention
HTTP & Prompt	`rules/caching-http.md`	HTTP cache headers, LLM prompt caching, semantic caching

Query & Data Fetching

TanStack Query v5 patterns for prefetching and optimistic updates.

Rule	File	Key Pattern
Prefetching	`rules/query-prefetching.md`	Hover prefetch, route loaders, queryOptions, Suspense
Optimistic Updates	`rules/query-optimistic.md`	Optimistic mutations, rollback, cache invalidation

Sustainability

Digital sustainability patterns for reducing carbon footprint and energy usage.

Rule	File	Key Pattern
Sustainability UX	`rules/sustainability-ux.md`	Page weight budgets, AVIF/WebP, lazy loading, dark mode

Local Profiling Target

When profiling a local app (Lighthouse, Core Web Vitals, bundle analysis), use Portless named URLs for stable, self-documenting targets:

bash

# Discover services
portless list
# app → app.localhost (port 3000)

# Profile with agent-browser (preferred for visual metrics)
agent-browser open "https://app.localhost"
agent-browser profiler start
agent-browser wait --load networkidle
agent-browser profiler stop /tmp/profile.json

# Lighthouse via agent-browser
agent-browser open "https://app.localhost"
agent-browser screenshot /tmp/perf-baseline.png

# Or direct Lighthouse CLI
npx lighthouse https://app.localhost --output=json --output-path=/tmp/lighthouse.json

Named URLs are stable across restarts and self-documenting in performance reports. Install Portless with npm i -g portless.

Quick Start Example

tsx

// LCP: Priority hero image with SSR
import Image from 'next/image';

export default async function Page() {
  const data = await fetchHeroData();
  return (
    <Image
      src={data.heroImage}
      alt="Hero"
      priority
      placeholder="blur"
      sizes="100vw"
      fill
    />
  );
}

Key Decisions

Decision	Recommendation
Memoization	Let React Compiler handle it (2026 default)
Lists 100+ items	Use TanStack Virtual
Image format	AVIF with WebP fallback (30-50% smaller)
LCP content	SSR/SSG, never client-side fetch
Code splitting	Per-route for most apps, per-component for heavy widgets
Prefetch strategy	On hover for nav links, viewport for content
Quantization	AWQ for 4-bit, FP8 for H100/H200
Bundle budget	Hard fail in CI to prevent regression

Common Mistakes

Client-side fetching LCP content (delays render)
Images without explicit dimensions (causes CLS)
Lazy loading LCP images (delays largest paint)
Heavy computation in event handlers (blocks INP)
Layout-shifting animations (use transform instead)
Lazy loading tiny components < 5KB (overhead > savings)
Missing error boundaries on lazy components
Using GPTQ without calibration data
Not benchmarking actual workload patterns
Only measuring in lab environment (need RUM)

ork:react-server-components-framework - Server-first rendering
ork:vite-advanced - Build optimization
browser-tools - Visual profiling with agent-browser + Portless
caching - Cache strategies for responses
ork:monitoring-observability - Production monitoring and alerting
ork:database-patterns - Query and index optimization
ork:llm-integration - Local inference with Ollama

Capability Details

lcp-optimization

Keywords: LCP, largest-contentful-paint, hero, preload, priority, SSR Solves:

Optimize hero image loading
Server-render critical content
Preload and prioritize LCP resources

Show full SKILL.md (457 more words)Show less

inp-optimization

Keywords: INP, interaction, responsiveness, long-task, transition, yield Solves:

Break up long tasks with scheduler.yield
Defer non-urgent updates with useTransition
Optimize event handler performance

cls-prevention

Keywords: CLS, layout-shift, dimensions, aspect-ratio, font-display Solves:

Reserve space for dynamic content
Prevent font flash and image pop-in
Use transform for animations

react-compiler

Keywords: react-compiler, auto-memo, memoization, React 19 Solves:

Enable automatic memoization
Identify when manual memoization needed
Verify compiler is working

virtualization

Keywords: virtual, TanStack, large-list, scroll, overscan Solves:

Render 100+ item lists efficiently
Dynamic height virtualization
Window scrolling patterns

lazy-loading

Keywords: React.lazy, Suspense, code-splitting, dynamic-import Solves:

Route-based code splitting
Component lazy loading with error boundaries
Prefetch on hover and viewport

image-optimization

Keywords: next/image, AVIF, WebP, responsive, blur-placeholder Solves:

Next.js Image component patterns
Format selection and quality settings
Responsive sizing and CDN configuration

profiling

Keywords: profiler, flame-graph, py-spy, DevTools, bundle-analyzer Solves:

Profile React renders and backend code
Generate and interpret flame graphs
Analyze and optimize bundle size

inp-advanced

Keywords: INP, scheduler-yield, layout-thrashing, third-party-scripts, requestAnimationFrame Solves:

Break long tasks with scheduler.yield()
Audit and defer blocking third-party scripts
Avoid synchronous layout thrashing in event handlers
Optimize form submissions, dropdowns, accordions, filters

sustainability

Keywords: sustainability, carbon-footprint, page-weight, green-ux, dark-mode, lazy-loading Solves:

Enforce page weight budgets (< 1MB)
Eliminate auto-playing videos and heavy decorative animations
Serve optimized image formats (AVIF/WebP)
Implement cursor-based pagination to prevent over-fetching

llm-inference

Keywords: vllm, quantization, speculative-decoding, inference, throughput Solves:

Deploy LLMs with vLLM for production
Choose quantization method for hardware
Accelerate generation with speculative decoding

Upstream coverage (do not restate)

These topics used to be restated in this skill's references, checklists, and examples. They are owned by first-party sources now; consult those instead of re-adding tutorials here. The ork-specific floors and scars that survived the cut live in references/ork-delta.md.

Topic	First-party source
Core Web Vitals mechanics, audit checklists, before/after examples	skill: web-perf / cloudflare:web-perf (Chrome DevTools MCP); https://web.dev/vitals/
Real User Monitoring with the web-vitals library	skill: web-perf; https://github.com/GoogleChrome/web-vitals
Next.js Image component, v16 image config defaults, image CDN loaders	skills: vercel:nextjs + vercel:next-upgrade; https://nextjs.org/docs/app/api-reference/components/image
Image format selection and optimization checklists	skill: vercel:nextjs; https://web.dev/learn/images
React Compiler migration, memoization escape hatches, state colocation	skill: vercel-react-best-practices; https://react.dev/learn/react-compiler
React DevTools Profiler workflow, render audits	skill: vercel-react-best-practices; https://react.dev/reference/react/Profiler
TanStack Virtual list/grid virtualization patterns	https://tanstack.com/virtual/latest/docs/introduction
Route-based code splitting (React Router, Vite manual chunks)	https://reactrouter.com/ and https://vite.dev/guide/build
Generic profiling workflows (Lighthouse, py-spy, bundle analyzers)	skill: web-perf; https://github.com/benfred/py-spy
Redis and HTTP caching strategy patterns	skill: upstash-redis-js; https://redis.io/docs/latest/
vLLM deployment, quantization, speculative decoding, edge inference	https://docs.vllm.ai/
Full-stack performance audit walkthrough	https://developer.chrome.com/docs/lighthouse/; ork delta in `references/ork-delta.md` + `examples/orchestkit-performance-wins.md`

References

Load on demand with Read("references/<file>"):

File	Content
`ork-delta.md`	OrchestKit floors, scars, and house decisions for this skill
`cc-prompt-cache-guide.md`	CC 2.1.72 prompt cache optimization, stable-first prompt structure
`database-optimization.md`	Postgres indexing and N+1 fixes backing the recorded audit wins

Real production before/after evidence (cache hierarchy, cost math): examples/orchestkit-performance-wins.md.

Files

SKILL.md and 44 other files (scripts, references) in src/skills/performance of yonatangross/orchestkit.

SKILL.md
examples/orchestkit-performance-wins.md
metadata.json
references/cc-prompt-cache-guide.md
references/database-optimization.md
references/ork-delta.md
rules/_sections.md
rules/_template.md
rules/caching-http.md
rules/caching-redis.md
rules/cwv-cls.md
rules/cwv-inp-advanced.md
rules/cwv-inp.md
rules/cwv-lcp.md
rules/images-formats.md
rules/images-responsive.md
rules/inference-quantization.md
rules/inference-speculative.md
… and 27 more

Open the folder on GitHubat commit 0ef71d2

Compare with similar skills

Performance next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Performance compared with similar skills
Skill	Stars	Used in	Tokens	Auto-check	Licence	Repo updated
Performance this skillyonatangross/orchestkit	289	—	~3.5k	Automated safety check: Pass	MIT	yesterday
Reduce Bundle Sizekcsujeet/ilamy-calendar	351	—	~2.9k	Automated safety check: Pass	MIT	5 days ago
React Doctormakeplane/plane	61k	12 repos	~657	Automated safety check: Pass	AGPL-3.0	yesterday
React Frontend Development Guidelinesdiet103/claude-code-infrastructure-showcase	10k	2 repos	~2.9k	Automated safety check: Pass	MIT	2 mo ago
Core Web VitalsvmDeshpande/ai-agent-automation	178	4 repos	~3.6k	Automated safety check: Pass	MIT	26 days ago
Shader for Interfacesv2space-labs/shader-for-interfaces	115	—	~3.1k	Automated safety check: Pass	MIT	1 mo ago

Similar skills

Reduce Bundle Size
kcsujeet/ilamy-calendar
Systematically reduce the shipped bundle size of a JS/TS library without sacrificing code readability or breaking consumer APIs.
351 GitHub stars~2.9k tokensUpdated 5 days ago
Frontend & DesignAuto-check passed
React Doctor
makeplane/plane
Scans React code for lint, accessibility, bundle size and architecture issues, reports a health score and checks that changes do not lower it.
61k GitHub starsUsed in 12 repos~657 tokens
Frontend & DesignAuto-check passed
React Frontend Development Guidelines
diet103/claude-code-infrastructure-showcase
Guidelines for React 18 and TypeScript apps covering Suspense data fetching, lazy loading, feature folders, MUI v7 styling, TanStack Router and performance.
10k GitHub starsUsed in 2 repos~2.9k tokens
Frontend & DesignAuto-check passed
Core Web Vitals
vmDeshpande/ai-agent-automation
Optimize Core Web Vitals (LCP, INP, CLS) for better page experience and search ranking.
178 GitHub starsUsed in 4 repos~3.6k tokens
Frontend & DesignAuto-check passed
Shader for Interfaces
v2space-labs/shader-for-interfaces
Decides whether an interface effect belongs in CSS, SVG, Canvas 2D, WebGL or WebGPU, then builds, debugs and visually verifies focused GPU effects inside product UIs.
115 GitHub stars~3.1k tokensUpdated 1 mo ago
Frontend & DesignAuto-check passed
Ssr Boost Migrate
Lomray-Software/vite-ssr-boost
Migrate an existing Vite and React Router SPA to vite-ssr-boost SSR in Data mode, preserving route objects and checking streaming, hydration, bundle size, and deployment readiness.
118 GitHub stars~2.3k tokensUpdated 16 days ago
Frontend & DesignAuto-check passed

Questions about Performance

What does Performance do?

Performance optimization patterns covering Core Web Vitals, React render optimization, lazy loading, image optimization, backend profiling, LLM inference, and sustainability UX. Performance is an agent skill from yonatangross/orchestkit. Performance optimization patterns covering Core Web Vitals, React render optimization, lazy loading, image optimization, backend profiling, LLM inference, and sustainability UX.

When should I use Performance?

Performance fits situations like: improving page speed; debugging slow renders; optimizing bundles; reducing image payload.

How do I install Performance in Claude Code?

Run `npx skills add yonatangross/orchestkit --skill performance -a claude-code`. Or copy the skill folder (src/skills/performance in yonatangross/orchestkit) into .claude/skills/performance in your project. Claude Code loads it when a task matches its description.

How do I install Performance in Codex?

Run `npx skills add yonatangross/orchestkit --skill performance -a codex`. Or copy the skill folder (src/skills/performance in yonatangross/orchestkit) into .agents/skills/performance in your project. Codex loads it when a task matches its description.

Can I use Performance in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add yonatangross/orchestkit --skill performance -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/performance, .gemini/skills/performance, .github/skills/performance and .opencode/skills/performance in your project.

What does Performance need to run?

Going by SKILL.md and its folder, Performance needs the command-line tools its instructions call (npx and npm). Our summary lists: Node.js. Its frontmatter pre-approves these tools: Read, Glob, Grep, WebFetch, WebSearch. Compatibility (from SKILL.md): Claude Code 2.1.277+..

Does Performance access the network?

SKILL.md names 10 domains. As links in the text: web.dev, github.com, react.dev, nextjs.org, tanstack.com, reactrouter.com, vite.dev, redis.io, docs.vllm.ai and developer.chrome.com. This is read from the text; nothing was executed.

Is Performance safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Performance use?

Performance is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Performance use?

About 3.5k tokens (SKILL.md is roughly 14k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 2.1k tokens, read only when the agent opens those files.

What are the alternatives to Performance?

Skills that share tags, products or a category with Performance: Reduce Bundle Size (kcsujeet/ilamy-calendar, 351 stars), React Doctor (makeplane/plane, 61k stars), React Frontend Development Guidelines (diet103/claude-code-infrastructure-showcase, 10k stars) and Core Web Vitals (vmDeshpande/ai-agent-automation, 178 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Performance?

yonatangross (a GitHub user) maintains it in yonatangross/orchestkit, which has 289 GitHub stars. The repository holds 108 skills in this directory. The repository was last updated on October 7, 2026.

Source: yonatangross/orchestkit on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.

Install Performance

Facts

At a glance

What it does

When your agent uses it

Example prompts

Requirements

Workflow steps

What it can do on your machine

Tool permissions

Runs code

Network

Credentials

Compatibility

Context cost

Safety

SKILL.md

Performance

Quick Reference

Core Web Vitals

2026 Thresholds

Render Optimization

Lazy Loading

Image Optimization

Profiling & Backend

LLM Inference

Caching

Query & Data Fetching

Sustainability

Local Profiling Target

Quick Start Example

Key Decisions

Common Mistakes

Related Skills

Capability Details

lcp-optimization

inp-optimization

cls-prevention

react-compiler

virtualization

lazy-loading

image-optimization

profiling

inp-advanced

sustainability

llm-inference

Upstream coverage (do not restate)

References

Files

Compare with similar skills

Similar skills

More from yonatangross/orchestkit

Related

Questions about Performance