К основному содержанию
скилл CX Codex

react-performance-optimizer — скилл для Claude Code

Скилл react-performance-optimizer находит узкие места в рендере React-приложений для достижения 60fps. Решает проблемы с зависанием списков и раздутыми бандлами.

MIT 215 установок ★ 274 обновлён 2026-10-30

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add curiositech/some_claude_skills --skill react-performance-optimizer -a claude-code
Открыть на GitHub

Что делает react-performance-optimizer

Скилл помогает обнаружить и устранить задержки клиентского интерфейса. Он активируется при рендере компонентов дольше 16 мс, лагах скролла или бандле больше 500 КБ. Внутри заложены готовые шаблоны: замена прямого вывода больших массивов на виртуализацию с react-window и вынесение маршрутов в lazy с Suspense.

Агент получает доступ к чтению, изменению файлов и запуску команд через npm. В инструкциях зафиксированы правила против избыточной мемоизации. Простые операции вроде склеивания строк оборачивать в useMemo запрещено, потому что накладные расходы хука превышают выигрыш. Для поиска лишних циклов обновления скилл привлекает React DevTools Profiler и библиотеку why-did-you-render.

Для небольших проектов до 10 компонентов этот скилл бесполезен из-за риска преждевременной оптимизации. С медленным бэкендом или сетевыми задержками он тоже не поможет, так как рассчитан только на логику React в браузере.

Какие задачи решает

  • внедрить виртуализацию списков длиннее 100 элементов через react-window
  • настроить разделение кода и ленивую загрузку маршрутов для бандлов более 500 КБ
  • устранить повторные перерисовки дочерних компонентов из-за нестабильных функций
  • вынести тяжёлые вычисления и сортировку за пределы тела рендера

Примеры запросов агенту

  • Оптимизируй список пользователей: при скролле 1000 элементов интерфейс дёргается.
  • Проверь компонент: рендер длится дольше 16 мс, найди нестабильные колбэки.
  • Настрой ленивую загрузку для роутов админки, бандл превысил 500 КБ.

Как установить react-performance-optimizer

1Через Skills CLI (Vercel)

npx skills add curiositech/some_claude_skills --skill react-performance-optimizer -a claude-code

2Вручную: положить файлы

~/.claude/skills/react-performance-optimizer/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/react-performance-optimizer/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о react-performance-optimizer

Как установить react-performance-optimizer в Claude Code?

Выполните команду npx skills add curiositech/some_claude_skills --skill react-performance-optimizer -a claude-code. Также можно скопировать файл вручную по пути ~/.claude/skills/react-performance-optimizer/SKILL.md.

Когда стоит запускать этот скилл?

Он нужен, если Profiler фиксирует рендеры дольше 16 мс, в списках больше 100 элементов или сжатый бандл весит свыше 500 КБ. Если интерфейс работает быстро, применять оптимизации заранее не рекомендуется.

Какие инструменты скилл использует для поиска проблем?

Для анализа применяются React DevTools Profiler, Lighthouse, webpack-bundle-analyzer и утилита why-did-you-render.

Исходный текст

SKILL.md · MIT
---
name: react-performance-optimizer
description: Optimize React apps for 60fps performance. Implements memoization, virtualization, code splitting, bundle optimization. Use for slow renders, large lists, bundle bloat. Activate on "React performance",
  "slow render", "useMemo", "bundle size", "virtualization". NOT for backend optimization, non-React frameworks, or premature optimization.
allowed-tools: Read,Write,Edit,Bash(npm:*)
metadata:
  tags:
  - react
  - performance
  - optimizer
  - react-performance
  - slow-render
  pairs-with:
  - skill: performance-profiling
    reason: React profiling tools identify the re-render bottlenecks that optimization addresses
  - skill: nextjs-app-router-expert
    reason: RSC and streaming SSR in Next.js require React-specific performance strategies
  - skill: data-viz-2025
    reason: Data-heavy visualizations require React memoization and virtualization for smooth rendering
  - skill: reactive-dashboard-performance
    reason: Dashboard widgets with real-time data need the same React optimization patterns
---

# React Performance Optimizer

Expert in diagnosing and fixing React performance issues to achieve buttery-smooth 60fps experiences.

## When to Use

✅ **Use for**:
- Slow component re-renders
- Large lists (>100 items) causing lag
- Bundle size >500KB (gzipped)
- Time to Interactive >3 seconds
- Janky scrolling or animations
- Memory leaks from unmounted components

❌ **NOT for**:
- Apps with <10 components (premature optimization)
- Backend API slowness (fix the API)
- Network latency (use caching/CDN)
- Non-React frameworks (use framework-specific tools)

## Quick Decision Tree

```
Is your React app slow?
├── Profiler shows >16ms renders? → Use memoization
├── Lists with >100 items? → Use virtualization
├── Bundle size >500KB? → Code splitting
├── Lighthouse score <70? → Multiple optimizations
└── Feels fast enough? → Don't optimize yet
```

---

## Technology Selection

### Performance Tools (2024)

| Tool | Purpose | When to Use |
|------|---------|-------------|
| React DevTools Profiler | Find slow components | Always start here |
| Lighthouse | Overall performance score | Before/after comparison |
| webpack-bundle-analyzer | Identify large dependencies | Bundle >500KB |
| why-did-you-render | Unnecessary re-renders | Debug re-render storms |
| React Compiler (2024+) | Automatic memoization | React 19+ |

**Timeline**:
- 2018: React.memo, useMemo, useCallback introduced
- 2020: Concurrent Mode (now Concurrent Rendering)
- 2022: Automatic batching in React 18
- 2024: React Compiler (automatic optimization)
- 2025+: React Compiler expected to replace manual memoization

---

## Common Anti-Patterns

### Anti-Pattern 1: Premature Memoization

**Novice thinking**: "Wrap everything in useMemo for speed"

**Problem**: Adds complexity and overhead for negligible gains.

**Wrong approach**:
```typescript
// ❌ Over-optimization
function UserCard({ user }) {
  const fullName = useMemo(() => `${user.first} ${user.last}`, [user]);
  const age = useMemo(() => new Date().getFullYear() - user.birthYear, [user]);

  return <div>{fullName}, {age}</div>;
}
```

**Why wrong**: String concatenation is faster than useMemo overhead.

**Correct approach**:
```typescript
// ✅ Simple is fast
function UserCard({ user }) {
  const fullName = `${user.first} ${user.last}`;
  const age = new Date().getFullYear() - user.birthYear;

  return <div>{fullName}, {age}</div>;
}
```

**Rule of thumb**: Only memoize if:
1. Computation takes &gt;5ms (use Profiler to measure)
2. Result used in dependency array
3. Prevents child re-renders

---

### Anti-Pattern 2: Not Memoizing Callbacks

**Problem**: New function instance on every render breaks React.memo.

**Wrong approach**:
```typescript
// ❌ Child re-renders on every parent render
function Parent() {
  const [count, setCount] = useState(0);

  return (
    <Child onUpdate={() => setCount(count + 1)} />
  );
}

const Child = React.memo(({ onUpdate }) => {
  return <button onClick={onUpdate}>Update</button>;
});
```

**Why wrong**: Arrow function creates new reference → React.memo useless.

**Correct approach**:
```typescript
// ✅ Stable callback reference
function Parent() {
  const [count, setCount] = useState(0);

  const handleUpdate = useCallback(() => {
    setCount(c => c + 1);  // Updater function avoids dependency
  }, []);

  return <Child onUpdate={handleUpdate} />;
}

const Child = React.memo(({ onUpdate }) => {
  return <button onClick={onUpdate}>Update</button>;
});
```

---

### Anti-Pattern 3: Rendering Large Lists Without Virtualization

**Problem**: Rendering 1000+ DOM nodes causes lag.

**Symptom**: Scrolling feels janky, initial render slow.

**Wrong approach**:
```typescript
// ❌ Renders all 10,000 items
function UserList({ users }) {
  return (
    <div>
      {users.map(user => (
        <UserCard key={user.id} user={user} />
      ))}
    </div>
  );
}
```

**Correct approach**:
```typescript
// ✅ Only renders visible items
import { FixedSizeList } from 'react-window';

function UserList({ users }) {
  return (
    <FixedSizeList
      height={600}
      itemCount={users.length}
      itemSize={50}
      width="100%"
    >
      {({ index, style }) => (
        <div style={style}>
          <UserCard user={users[index]} />
        </div>
      )}
    </FixedSizeList>
  );
}
```

**Impact**: 10,000 items: 5 seconds → 50ms render time.

---

### Anti-Pattern 4: No Code Splitting

**Problem**: 2MB bundle downloaded upfront, slow initial load.

**Wrong approach**:
```typescript
// ❌ Everything in main bundle
import AdminPanel from './AdminPanel';  // 500KB
import Dashboard from './Dashboard';
import Settings from './Settings';

function App() {
  return (
    <Routes>
      <Route path="/admin" element={<AdminPanel />} />
      <Route path="/dashboard" element={<Dashboard />} />
      <Route path="/settings" element={<Settings />} />
    </Routes>
  );
}
```

**Correct approach**:
```typescript
// ✅ Lazy load routes
import { lazy, Suspense } from 'react';

const AdminPanel = lazy(() => import('./AdminPanel'));
const Dashboard = lazy(() => import('./Dashboard'));
const Settings = lazy(() => import('./Settings'));

function App() {
  return (
    <Suspense fallback={<Loading />}>
      <Routes>
        <Route path="/admin" element={<AdminPanel />} />
        <Route path="/dashboard" element={<Dashboard />} />
        <Route path="/settings" element={<Settings />} />
      </Routes>
    </Suspense>
  );
}
```

**Impact**: Initial bundle: 2MB → 300KB.

---

### Anti-Pattern 5: Expensive Operations in Render

**Problem**: Heavy computation on every render.

**Wrong approach**:
```typescript
// ❌ Sorts on every render (even when data unchanged)
function ProductList({ products }) {
  const sorted = products.sort((a, b) => b.price - a.price);

  return <div>{sorted.map(p => <Product product={p} />)}</div>;
}
```

**Correct approach**:
```typescript
// ✅ Memoize expensive operation
function ProductList({ products }) {
  const sorted = useMemo(
    () => [...products].sort((a, b) => b.price - a.price),
    [products]
  );

  return <div>{sorted.map(p => <Product product={p} />)}</div>;
}
```

---

## Implementation Patterns

### Pattern 1: React.memo for Pure Components

```typescript
// Prevent re-render when props unchanged
const ExpensiveComponent = React.memo(({ data }) => {
  // Complex rendering logic
  return <div>{/* ... */}</div>;
});

// With custom comparison
const UserCard = React.memo(
  ({ user }) => <div>{user.name}</div>,
  (prevProps, nextProps) => {
    // Return true if props equal (skip re-render)
    return prevProps.user.id === nextProps.user.id;
  }
);
```

### Pattern 2: useMemo for Expensive Calculations

```typescript
function DataTable({ rows, columns }) {
  const sortedAndFiltered = useMemo(() => {
    console.log('Recomputing...');  // Only logs when rows/columns change

    return rows
      .filter(row => row.visible)
      .sort((a, b) => a.timestamp - b.timestamp);
  }, [rows, columns]);

  return <Table data={sortedAndFiltered} />;
}
```

### Pattern 3: useCallback for Stable References

```typescript
function SearchBox({ onSearch }) {
  const [query, setQuery] = useState('');

  // Stable reference, doesn't break child memoization
  const handleSubmit = useCallback(() => {
    onSearch(query);
  }, [query, onSearch]);

  return (
    <form onSubmit={handleSubmit}>
      <input value={query} onChange={e => setQuery(e.target.value)} />
    </form>
  );
}
```

### Pattern 4: Virtualization (react-window)

```typescript
import { VariableSizeList } from 'react-window';

function MessageList({ messages }) {
  const getItemSize = (index) => {
    // Dynamic heights based on content
    return messages[index].text.length > 100 ? 80 : 50;
  };

  return (
    <VariableSizeList
      height={600}
      itemCount={messages.length}
      itemSize={getItemSize}
      width="100%"
    >
      {({ index, style }) => (
        <div style={style}>
          <Message message={messages[index]} />
        </div>
      )}
    </VariableSizeList>
  );
}
```

### Pattern 5: Code Splitting with React.lazy

```typescript
// Route-based splitting
const routes = [
  { path: '/home', component: lazy(() => import('./Home')) },
  { path: '/about', component: lazy(() => import('./About')) },
  { path: '/contact', component: lazy(() => import('./Contact')) }
];

// Component-based splitting
const HeavyChart = lazy(() => import('./HeavyChart'));

function Dashboard() {
  const [showChart, setShowChart] = useState(false);

  return (
    <div>
      <button onClick={() => setShowChart(true)}>Show Chart</button>

      {showChart && (
        <Suspense fallback={<Spinner />}>
          <HeavyChart />
        </Suspense>
      )}
    </div>
  );
}
```

---

## Production Checklist

```
□ Profiler analysis completed (identified slow components)
□ Large lists use virtualization (&gt;100 items)
□ Routes code-split with React.lazy
□ Heavy components lazy-loaded
□ Callbacks memoized with useCallback
□ Expensive computations use useMemo
□ Pure components wrapped in React.memo
□ Bundle analyzed (no duplicate dependencies)
□ Tree-shaking enabled (ESM imports)
□ Images optimized and lazy-loaded
□ Lighthouse score &gt;90
□ Time to Interactive &lt;3 seconds
```

---

## When to Use vs Avoid

| Scenario | Optimize? |
|----------|-----------|
| Rendering 1000+ list items | ✅ Yes - virtualize |
| Sorting/filtering large arrays | ✅ Yes - useMemo |
| Passing callbacks to memoized children | ✅ Yes - useCallback |
| String concatenation | ❌ No - fast enough |
| Simple arithmetic | ❌ No - don't memoize |
| 10-item list | ❌ No - premature optimization |

---

## References

- `/references/profiling-guide.md` - How to use React DevTools Profiler
- `/references/bundle-optimization.md` - Reduce bundle size strategies
- `/references/memory-leaks.md` - Detect and fix memory leaks

## Scripts

- `scripts/performance_audit.ts` - Automated performance checks
- `scripts/bundle_analyzer.sh` - Analyze and visualize bundle

---

**This skill guides**: React performance optimization | Memoization | Virtualization | Code splitting | Bundle optimization | Profiling

© curiositech · MIT · curiositech/some_claude_skills

Похожие скиллы

Все скиллы по теме «Фронтенд и UI» →
react-performance oakoss Скилл react-performance для Claude Code собирает паттерны оптимизации React и включается автоматически в задачах о скорости приложения. CX Codex +1 163установок react-performance-expert carlrannaberg Субагент react-performance-expert ищет узкие места в React: медленные рендеры, лишние перерисовки, большие бандлы и проблемы с памятью. CX Codex ★ 763звёзд репо virtual-lists patterns.dev Скилл virtual-lists обучает агента технике виртуализации списков и таблиц в веб-приложениях. Помогает убрать задержки при скролле и ускорить начальную отрисовку страниц. CX Codex +1 1 700установок conductor-rewrite-performance boraoztunc Скилл conductor-rewrite-performance для Claude Code оптимизирует React-интерфейсы локальных десктопных приложений на Tauri, устраняя каскадные перерендеры и задержки при стриминге сообщений. CX Codex +1 186установок list-performance-function-references fcakyon Правило list-performance-function-references запрещает трансформировать массивы перед передачей в виртуализированные списки. Оно заставляет переносить вычисления внутрь элементов, сохраняя стабильные ссылки на данные. CX Codex +1 ★ 1 216звёзд репо react-vite-best-practices agent-skills Скилл react-vite-best-practices для Claude Code с 23 правилами оптимизации React-приложений на Vite: сборка, code splitting, HMR, ассеты, окружение и анализ бандла. Проверяет компоненты при написании и ревью. CX Codex +1 3 000установок

Из того же набора180

Весь набор →
devops-automator Скилл devops-automator для Claude Code проектирует CI/CD-pipeline, пишет Terraform и Kubernetes-манифесты, настраивает GitOps. Помогает строить инфраструктуру и автоматизировать развёртывание. CX Codex +1 219установок bot-developer Скилл bot-developer для Claude Code помогает проектировать ботов для Discord, Telegram и Slack — от обработки событий до ограничений запросов и модерации. Описывает чат-ботов с диалогами в несколько ходов. CX Codex +1 218установок prompt-engineer Скилл prompt-engineer для проектирования и отладки промптов. Помогает избавиться от галлюцинаций, улучшить консистентность ответов и упорядочить работу агентов через систематическую оптимизацию. CX Codex +1 217установок team-builder Скилл team-builder проектирует структуру команды по принципам организационной психологии. Если нужной роли нет в библиотеке скиллов, сразу создаёт её. CX Codex +1 216установок digital-estate-planner Скилл digital-estate-planner для Claude Code планирует цифровое наследство: учитывает аккаунты, пароли и криптоактивы, готовит инструкции доверенным лицам. Помогает подготовить доступ к данным на случай смерти или недееспособности. CX Codex +1 215установок data-pipeline-engineer Скилл data-pipeline-engineer проектирует пайплайны данных, слои Medallion, DAG для Airflow и модели dbt. Пригодится при настройке пакетной или потоковой обработки данных. CX Codex +1 215установок hipaa-compliance Скилл hipaa-compliance помогает проверять работу с PHI: аудит доступа, санитаризацию логов и требования к сессиям. Нужен при разработке функций с медицинскими данными. CX Codex +1 215установок web-wave-designer Скилл web-wave-designer для Claude Code генерирует водные эффекты для веба: океанские волны, рябь и подводное искажение. Создаёт живые фоны и интерфейсы с эффектом жидкости. CX Codex +1 214установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой