Skip to main content
skill CX Codex

react-patterns · oakoss — Claude Code skill: what it does, how to install

react-patterns is a Claude Code skill that covers React 19 patterns, state choices, data loading with use(), and reducing needless re-renders when building or reviewing components.

MIT 201 installs ★ 29 updated 2026-08-17

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add oakoss/agent-skills --skill react-patterns -a claude-code
Open on GitHub

What react-patterns does

The skill is a working reference for React 19. It pairs each pattern with the API to reach for, lists the mistakes that keep coming up, and says when a job belongs to a subagent. Data loading goes through use(), forms through useActionState, plus optimistic updates, useTransition, useEffectEvent, useId, and React.cache() with cacheSignal() on the server.

Nothing to type as a slash command: the metadata sets user-invocable: false, so the agent pulls the skill in once you ask for a component, a re-render investigation or a review. Work splits three ways. Explore profiles renders and bundle size, Task writes the feature, Plan maps the component tree and decides where state lives. Component variants and theming go to the shadcn-ui skill, utility classes to tailwind, when those are installed.

On a codebase with no React there is nothing here to use; the description rules out non-React frameworks and static sites without interactivity. Memoization advice is to let React Compiler do its job first and add useMemo or useCallback in specific spots only.

What it helps with

  • Swap forwardRef for a plain ref prop in React 19
  • Kill a chain of sequential awaits in the data layer
  • Trace re-renders back to a mutating array.sort()
  • Pick where state should live for a new screen
  • Wire a form with pending state through useActionState

Example prompts for the agent

  • Rewrite this component for React 19: ref as a normal prop, drop forwardRef
  • Why does this list re-render on every keystroke? Find the cause and strip the manual memoization
  • Move this fetch to use() with Suspense and delete the useEffect plus useState pair

How to install react-patterns

1Skills CLI (Vercel)

npx skills add oakoss/agent-skills --skill react-patterns -a claude-code

2Manually: put the files in place

~/.claude/skills/react-patterns/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/react-patterns/

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

Questions about react-patterns

How to install react-patterns in Claude Code?

Run npx skills add oakoss/agent-skills --skill react-patterns -a claude-code. The skill lands at ~/.claude/skills/react-patterns/SKILL.md and gets picked up on the next start.

What does react-patterns do?

It hands the agent a React 19 map: which hook or API fits a given job, which mistakes to avoid, and when to pass the task to the Explore, Task or Plan subagent.

Does the skill work outside Claude?

Yes. Codex, Cursor, Gemini CLI and OpenCode each take their own -a value on the same npx skills add line. GitHub Copilot uses gh skill install oakoss/agent-skills react-patterns instead.

Source text

SKILL.md · MIT
---
name: react-patterns
description: |
  React 19+ patterns, performance optimization, and component architecture. Covers hooks, state management decision trees, data fetching with use() API, Server Components, React Compiler, bundle optimization, and re-render elimination.

  Use when building components, optimizing re-renders, fetching data, managing state, handling forms, structuring frontends, or reviewing React code.
license: MIT
metadata:
  author: oakoss
  version: '1.1'
  source: 'https://react.dev'
user-invocable: false
---

# React

## Overview

Covers component architecture, performance optimization, state management, data fetching, and modern React 19+ APIs. Prioritizes React Compiler compatibility, Server Components, and elimination of data fetching waterfalls.

**When to use:** Building React applications, optimizing performance, choosing state management, implementing data fetching, reviewing component architecture.

**When NOT to use:** Non-React frameworks, purely server-side rendering without React, static sites without interactivity.

## Quick Reference

| Pattern               | API / Approach                                    | Key Points                                          |
| --------------------- | ------------------------------------------------- | --------------------------------------------------- |
| Data fetching         | `use(dataPromise)`                                | Replaces useEffect+useState fetch pattern           |
| Form handling         | `useActionState(action, init)`                    | Built-in pending states and error handling          |
| Optimistic UI         | `useOptimistic(state, updateFn)`                  | Instant feedback while server processes             |
| Non-urgent updates    | `useTransition()`                                 | Mark updates as interruptible                       |
| Effect events         | `useEffectEvent(fn)`                              | Reactive values without re-triggering effects       |
| Form pending status   | `useFormStatus()`                                 | Read parent form pending state from child component |
| Unique IDs            | `useId()`                                         | Hydration-safe IDs for accessibility                |
| Server state          | React Query / `useSuspenseQuery`                  | Caching, deduplication, background refetch          |
| Client state (local)  | `useState` / `useRef`                             | Single component or transient values                |
| Client state (global) | Zustand / Context                                 | Cross-component client-only state                   |
| Derived state         | Compute during render                             | Never sync derived values with effects              |
| Lazy initialization   | `useState(() => expensive())`                     | Avoid eager computation on every render             |
| Component types       | Page, Feature, UI                                 | Route entry, business logic, reusable primitives    |
| Memoization           | Trust React Compiler first                        | Manual useMemo/useCallback only when needed         |
| Ref as prop           | `ref` prop on function components                 | No `forwardRef` needed in React 19                  |
| Ref cleanup           | Return function from ref callback                 | Cleanup runs on detach instead of `null` call       |
| Code splitting        | `React.lazy()` + Suspense                         | Lazy-load heavy components                          |
| Parallel fetches      | `Promise.all()`                                   | Eliminate sequential await waterfalls               |
| Request dedup         | `React.cache()`                                   | Per-request server-side deduplication               |
| Abort server work     | `cacheSignal()`                                   | Cancel expensive async work when client disconnects |
| Resource preloading   | `prefetchDNS`, `preconnect`, `preload`, `preinit` | Optimize resource loading from components           |
| State preservation    | `<Activity>`                                      | Hide UI while keeping state mounted                 |

## Common Mistakes

| Mistake                                                     | Correct Pattern                                                                                         |
| ----------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
| Fetching data in useEffect with useState                    | Use the `use()` API or React Query for data fetching with built-in caching                              |
| Storing derived values in state and syncing with effects    | Compute derived values during render; never use effects for state synchronization                       |
| Wrapping everything in useMemo and useCallback              | Trust React Compiler first; only add manual memoization for expensive computations or memoized children |
| Using `array.sort()` which mutates state                    | Use `array.toSorted()` for immutable sorting to avoid unexpected re-renders                             |
| Using `&&` for conditional rendering                        | Use ternary `condition ? <Component /> : null` to avoid rendering falsy values like `0`                 |
| Using Math.random() or Date for IDs                         | Use `useId()` for hydration-safe unique identifiers                                                     |
| Putting reactive values in effect deps to read latest value | Use `useEffectEvent` to access latest values without re-triggering effects                              |
| Creating object literals as effect dependencies             | Hoist static objects outside the component or use primitive dependencies                                |
| Using `forwardRef` in React 19 projects                     | Pass `ref` directly as a prop; `forwardRef` is deprecated in React 19                                   |
| Mutating props or state during render                       | Follow Rules of React for React Compiler compatibility: pure renders, no side effects                   |

## Delegation

- **Explore component architecture and identify performance bottlenecks**: Use `Explore` agent to profile re-renders, analyze bundle size, and trace data fetching waterfalls
- **Implement React feature with proper patterns**: Use `Task` agent to build components following Server Component, Suspense, and React 19 conventions
- **Design frontend architecture and state management strategy**: Use `Plan` agent to structure component hierarchy, select state management, and plan data fetching approach

> If the `shadcn-ui` skill is available, delegate component variant and theming questions to it.
> If the `tailwind` skill is available, delegate utility-first styling and design token questions to it.
> If the `zustand` skill is available, delegate global client state management questions to it.

## References

- [Component patterns, state management, and useEffect decisions](references/component-patterns.md)
- [Performance optimization: waterfalls, bundles, and re-renders](references/performance-optimization.md)
- [Hooks, Server Actions, and React 19 APIs](references/hooks-and-actions.md)
- [React Compiler patterns and re-render optimization](references/react-compiler.md)
- [Server-side rendering and React Server Components](references/server-side.md)
- [Anti-patterns and troubleshooting guide](references/anti-patterns.md)

© oakoss · MIT · oakoss/agent-skills

Similar skills

All skills for Frontend and UI →

react-patterns by other authors comes first.

react-patterns affaan-m react-patterns — a skill for Claude and other AI editors that steers the agent toward idiomatic React 18/19: hooks discipline, server/client boundaries, forms, data fetching. CX Codex +1 6,700installs react-patterns jezweb react-patterns — a skill that checks React 19 components for waterfalls, bundle bloat and re-renders, and suggests composition fixes. Useful while writing or reviewing code. CX Codex +1 1,300installs react-patterns giuseppe-trisciuoglio react-patterns teaches your agent React 19 and Next.js App Router patterns: Server Components, Server Actions, useOptimistic, Suspense boundaries. Useful when the app is already on React 19. CX Codex +1 5,000installs react-patterns manutej A skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that teaches the agent modern React patterns, from hooks and component composition to state management. Covers React 18+, Server Components, and memoization. CX Codex +1 474installs react-patterns davila7 react-patterns is a Claude Code skill that guides React component, hook, and state choices. Use it while building or refactoring TypeScript interfaces. CX Codex +1 321installs react-expert https://github.com/Jeffallan react-expert — a skill for React 18+, Next.js App Router, and create-react-app work. It writes components and hooks, debugs rendering, and migrates class components to functions. CX Codex +1 5,900installs react-dev softaworks react-dev provides type-safe React 18 and 19 patterns for TypeScript components, hooks, and Server Actions. CX Codex +1 4,200installs 101-react-patterns obviousworks 101-react-patterns — a rule for React components: functional components, hooks for logic, Server Components by default. +1 ★ 97repo stars react-fetch-cache-patterns pproenca react-fetch-cache-patterns — a skill with 48 rules for scalable data fetching and caching in React: request orchestration, backend protection, prefetching, error resilience. CX Codex +1 180installs react19-concurrent-patterns official github react19-concurrent-patterns preserves React 18 concurrent patterns during React 19 migrations and guides the adoption of use(), useOptimistic, and Actions. CX Codex +1 1,100installs react pproenca A skill with 49 React 19 rules and a codebase review algorithm. Useful when writing components, migrating from React 18, or auditing a repo. CX Codex +1 505installs

From the same set106

The whole set →
knowledge-graph-builder The knowledge-graph-builder skill guides knowledge-graph design, graph database choice, and graph-plus-vector retrieval. Use it for Graph RAG, entity resolution, and fact checks. CX Codex +1 222installs pino-logging Set up structured Pino logging in Node.js, including request context, sensitive-field redaction, transports, and framework integrations. CX Codex +1 217installs database-security database-security audits the data layer of Supabase, Postgres and Convex apps: RLS coverage, policy holes, service-role leaks, audit logging. Useful before a release or after an incident. CX Codex +1 208installs typescript-patterns Provides advanced strict-mode TypeScript patterns to enforce type safety and stop runtime errors before code runs. CX Codex +1 202installs ci-cd-architecture ci-cd-architecture is a Claude Code skill for planning CI/CD pipelines, comparing deployment platforms, and securing GitHub Actions. It supports preparing a project for production or changing its delivery setup. CX Codex +1 199installs openapi Guides the agent in writing OpenAPI 3.1 schemas and generating TypeScript clients. Ideal for REST API contract design and schema validation. CX Codex +1 197installs css-animation-patterns css-animation-patterns is a Claude Code skill for CSS animation work. It guides agents on composite properties, transitions, and newer motion APIs. CX Codex +1 196installs pnpm-workspace pnpm-workspace teaches coding agents to configure pnpm monorepos and version catalogs. Useful when managing multi-package repositories. CX Codex +1 195installs

Project sponsors

Companies that keep this analytics open