React 19: What Actually Matters for Your App

React 19 shipped with a stack of features that changes how you write real applications. Some of it is quietly transformative. Some of it is oversold. Here's what actually moves the needle after six months of production use.

The compiler is the story

The React Compiler auto-memoizes components and hooks at build time. If you've spent years sprinkling useMemo and useCallback like salt, you can stop. The compiler does it better than you did, and it does it everywhere — including inside third-party libraries you haven't touched.

• Delete most manual memoization — the compiler covers it
• Keep memoization only where you've measured a real hot path
• Trust the ESLint plugin to warn you when a component opts out

Actions and useActionState

Form submissions used to be five hooks glued together: pending state, error state, optimistic updates, a submit handler, and a ref. Actions collapse the whole pattern.

function EditName({ id, name }: { id: string; name: string }) {
  const [error, submit, pending] = useActionState(
    async (_prev, formData: FormData) => {
      const next = formData.get("name") as string;
      const res = await updateName(id, next);
      return res.ok ? null : res.error;
    },
    null,
  );

  return (
    <form action={submit}>
      <input name="name" defaultValue={name} disabled={pending} />
      <button disabled={pending}>{pending ? "Saving…" : "Save"}</button>
      {error && <p role="alert">{error}</p>}
    </form>
  );
}

use() is not what you think it is

use() unwraps promises and context. It sounds like a way to fetch data inside components. It isn't — or at least, not without a framework that owns the data lifecycle. Treat use() as a primitive for Server Component-aware frameworks and for reading context conditionally. Don't reach for it in leaf components.

What to skip

You do not need to migrate everything on day one. The team's own migration guide is explicit: React 19 is backward compatible for typical apps. The compiler is opt-in. Actions are additive. Ship features first, adopt features when the cost is zero.

"The best framework upgrade is the one your users never notice."

Practice what you'll actually ship

The fastest way to internalize any of this is to build against it. Pick a small problem — a debounced search, a toggle, an optimistic list — and rewrite it three ways: React 17, React 18, React 19. You'll feel the difference before you can articulate it.

Don't just read about it — build it. Try the useActionState challenge