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
npx skills add oakoss/agent-skills --skill react-patterns -a claude-codeWhat 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
forwardReffor a plainrefprop 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:
refas a normal prop, dropforwardRef - Why does this list re-render on every keystroke? Find the cause and strip the manual memoization
- Move this fetch to
use()withSuspenseand delete theuseEffectplususeStatepair
How to install react-patterns
1Skills CLI (Vercel)
npx skills add oakoss/agent-skills --skill react-patterns -a claude-code2Manually: put the files in place
~/.claude/skills/react-patterns/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/react-patterns/
1Skills CLI (Vercel)
npx skills add oakoss/agent-skills --skill react-patterns -a codex2Manually: put the files in place
.agents/skills/react-patterns/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add oakoss/agent-skills --skill react-patterns -a cursor2Manually: put the files in place
.cursor/skills/react-patterns/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install oakoss/agent-skills skills/react-patterns2Manually: put the files in place
.github/skills/react-patterns/SKILL.md1Skills CLI (Vercel)
npx skills add oakoss/agent-skills --skill react-patterns -a gemini-cli2Platform CLI
gemini skills install https://github.com/oakoss/agent-skills --path skills/react-patternsManually: put the files in place
.devin/skills/react-patterns/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add oakoss/agent-skills --skill react-patterns -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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.