react-19
React 19 patterns with React Compiler. Trigger: When writing React components - no useMemo/useCallback needed.
When & Why to Use This Skill
This Claude skill optimizes React development by enforcing React 19 best practices and leveraging the React Compiler. It streamlines codebase modernization by eliminating manual memoization (useMemo/useCallback), implementing Server Components by default, and utilizing the latest hooks like use() and useActionState for more efficient data fetching and state management.
Use Cases
- Modernizing legacy React codebases by removing redundant manual memoization hooks, allowing the React Compiler to handle performance optimizations automatically.
- Architecting high-performance web applications using a 'Server Components First' approach to reduce client-side bundle sizes and improve SEO.
- Simplifying complex asynchronous logic and conditional context usage through the new use() hook and Suspense integration.
- Implementing robust form handling and server-side mutations with the Actions API and useActionState to manage pending states and feedback seamlessly.
- Refactoring component libraries to use the simplified React 19 ref-as-prop pattern, eliminating the need for the forwardRef higher-order component.
| name | react-19 |
|---|---|
| description | > |
| Trigger | When writing React components - no useMemo/useCallback needed. |
| license | Apache-2.0 |
| author | gentleman-programming |
| version | "1.0" |
No Manual Memoization (REQUIRED)
// ✅ React Compiler handles optimization automatically
function Component({ items }) {
const filtered = items.filter(x => x.active);
const sorted = filtered.sort((a, b) => a.name.localeCompare(b.name));
const handleClick = (id) => {
console.log(id);
};
return <List items={sorted} onClick={handleClick} />;
}
// ❌ NEVER: Manual memoization
const filtered = useMemo(() => items.filter(x => x.active), [items]);
const handleClick = useCallback((id) => console.log(id), []);
Imports (REQUIRED)
// ✅ ALWAYS: Named imports
import { useState, useEffect, useRef } from "react";
// ❌ NEVER
import React from "react";
import * as React from "react";
Server Components First
// ✅ Server Component (default) - no directive
export default async function Page() {
const data = await fetchData();
return <ClientComponent data={data} />;
}
// ✅ Client Component - only when needed
"use client";
export function Interactive() {
const [state, setState] = useState(false);
return <button onClick={() => setState(!state)}>Toggle</button>;
}
When to use "use client"
- useState, useEffect, useRef, useContext
- Event handlers (onClick, onChange)
- Browser APIs (window, localStorage)
use() Hook
import { use } from "react";
// Read promises (suspends until resolved)
function Comments({ promise }) {
const comments = use(promise);
return comments.map(c => <div key={c.id}>{c.text}</div>);
}
// Conditional context (not possible with useContext!)
function Theme({ showTheme }) {
if (showTheme) {
const theme = use(ThemeContext);
return <div style={{ color: theme.primary }}>Themed</div>;
}
return <div>Plain</div>;
}
Actions & useActionState
"use server";
async function submitForm(formData: FormData) {
await saveToDatabase(formData);
revalidatePath("/");
}
// With pending state
import { useActionState } from "react";
function Form() {
const [state, action, isPending] = useActionState(submitForm, null);
return (
<form action={action}>
<button disabled={isPending}>
{isPending ? "Saving..." : "Save"}
</button>
</form>
);
}
ref as Prop (No forwardRef)
// ✅ React 19: ref is just a prop
function Input({ ref, ...props }) {
return <input ref={ref} {...props} />;
}
// ❌ Old way (unnecessary now)
const Input = forwardRef((props, ref) => <input ref={ref} {...props} />);
Keywords
react, react 19, compiler, useMemo, useCallback, server components, use hook