React Compiler is one of the most-discussed frontend shifts of 2026, and it's a genuinely good idea: automatic memoization, handled at build time, so you stop hand-writing useMemo and useCallback to prevent re-renders. DevStash doesn't use it. Not because it's bad — because of one specific, boring constraint already written into this project's own rules, and it's worth explaining rather than quietly skipping the topic.
What it actually does#
Before React Compiler, avoiding unnecessary re-renders was manual work: wrap an expensive computation in useMemo, wrap a callback passed to a memoized child in useCallback, and hope you remembered every dependency correctly.
// Manual memoization — the pattern React Compiler exists to remove
const sorted = useMemo(() => items.sort(compareFn), [items])
const handleClick = useCallback(() => onSelect(id), [id, onSelect])React Compiler analyzes your component code at build time and inserts that memoization for you automatically, based on what actually changes between renders — no useMemo, no useCallback, no dependency array to get subtly wrong. It's a compiler pass, not a runtime library: the optimization happens once, when you build, not on every render in the browser.
That's a real, structural improvement over the old pattern. Hand-written memoization has a well-known failure mode — a wrong or missing dependency silently breaks the optimization, or worse, causes a stale-closure bug that only shows up in production. A compiler doing the same analysis mechanically doesn't make that class of mistake.
The specific reason this project hasn't adopted it#
This site's own CLAUDE.md pins exact versions, not ranges: react 19.2.4 and react-dom 19.2.4, called out explicitly as "exact pin, not caret-ranged." That's a deliberate hard constraint, put in place after enough breaking changes across this stack (Zod v3→v4, Tailwind v3→v4, @next/mdx vs next-mdx-remote) to make "add a new build-time dependency that touches every component" a decision that gets made on purpose, not picked up incidentally through a routine update.
React Compiler is still explicitly framed as new tooling with each release bringing meaningful changes to its own optimization heuristics — it earns different results depending on the exact compiler version, not just the React version underneath it. Adopting it on a strict-pin project means also pinning and actively tracking that dependency's changes, on top of the two already being tracked. For a site where every page is already a Server Component by default (one of the App Router patterns I actually use: use client only when genuinely interactive) the actual client-side re-render surface is small — a handful of interactive components like the mobile nav, theme toggle, and the illustration generator's controls. The manual useMemo/useCallback burden that React Compiler removes is a much smaller problem here than it would be on a client-heavy dashboard.
The part people skip: it can bail out on your components#
React Compiler only optimizes code it can prove is safe to optimize. Its whole analysis assumes your components follow the Rules of React — pure render functions, no mutation of props or state during render, hooks called unconditionally. When it encounters a component that breaks those rules, it doesn't guess and it doesn't crash your build. It skips that component and moves on.
That's the right behavior, but it has a consequence worth stating plainly: you can add React Compiler to a codebase, see the build succeed, ship it, and get substantially less optimization than you think — because the components with the worst re-render problems are often exactly the ones doing something irregular enough to make the compiler bail.
"The build passed" is not the same claim as "my components are being optimized."
How to find out if your code is ready — without adopting anything#
This is the genuinely useful part, and it costs nothing: the compiler's analysis is available as an ESLint plugin, separately from the compiler itself.
pnpm add -D eslint-plugin-react-hooks@latestThe modern react-hooks plugin ships the compiler's diagnostics as lint rules. Turning them on tells you which components violate the Rules of React — which is to say, exactly which components the compiler would refuse to optimize — without changing a single byte of your build output.
That's worth running even if you never intend to adopt the compiler, because every rule it flags is a real correctness smell in its own right. Mutating a prop during render is a bug whether or not a compiler is watching. In that sense the linter is the useful half of the tool, and it's the half you can adopt with zero risk.
If you do decide to go further, on Next.js it's one flag:
// next.config.ts
const nextConfig = {
experimental: { reactCompiler: true },
}Then measure. Use React DevTools' Profiler to record the same interaction before and after — if your re-render surface was already small, you will genuinely see very little, and that's a finding, not a failure.
When it would actually change the math#
If a future page here needed a genuinely re-render-heavy client component — something closer to the illustration generator's live SVG preview, recomputing on every slider drag — that's exactly the shape of problem React Compiler is built for, and the calculation would flip: the safety win from automatic, correct memoization would clearly outweigh the cost of tracking one more pinned dependency.
The honest position is: not "we evaluated it and rejected it," but "the constraint that's already load-bearing on this project (exact version pins, mostly-server-rendered pages) makes this a low-value place to adopt it right now, and a specific, checkable condition — a genuinely re-render-heavy client component landing on the site — is what would change that." That's a more useful thing to write down than either blanket hype or blanket skepticism.
Quick answers
What does React Compiler do?
It analyses components at build time and inserts memoization automatically, so you stop hand-writing useMemo, useCallback and dependency arrays.
Why is DevStash not using it yet?
The project pins exact React versions on purpose, and the compiler's optimisation heuristics change with each release, so results depend on the exact compiler version as well as the React version.
Can the compiler skip my components?
Yes. It only optimises code it can prove safe and bails out on components that break the Rules of React, so a passing build does not mean your components are being optimised.
How can I check readiness without adopting it?
Install the latest eslint-plugin-react-hooks, which ships the compiler's diagnostics as lint rules and shows which components it would refuse to optimise.
Need something like this built or fixed?
Custom websites, landing pages and speed fixes. I reply within 24 hours.
Adesh Shukla
Front-end developer who came to the web from accounts, by way of an interest in UX. Building DevStash — a developer ecosystem covering automation, AI workflows, and modern frontend systems.