Skip to content
Skillpedia
Websites & UI (frontend)40k · #5332

react19-concurrent-patterns

Has your agent adapt React code to use the new concurrency features of React 19. This improves application performance and responsiveness.

What it does

This tool helps ensure your React code, when updated to version 19, continues to work correctly with concurrency features that already existed in version 18. It also suggests when to adopt new features from version 19.

When to use it

  • ✓When updating a React project from an older version to version 19.
  • ✓To verify that important parts of the code dealing with performance (concurrency) have not been broken.
  • ✓After the main update is stable, to decide which new React 19 features can be added.

Example of what to ask your AI

“Check if the code for transitions (`useTransition`) and deferred values (`useDeferredValue`) has been kept intact during the React 19 upgrade.”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/github/awesome-copilot/blob/main/skills/react19-concurrent-patterns/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/github/awesome-copilot/blob/main/skills/react19-concurrent-patterns/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

The tool checks if the parts of your code using `useTransition`, `useDeferredValue`, and `Suspense` (for loading parts of the screen) have not been accidentally changed. It also points out new React 19 features that can be used after the update is stable.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add github/awesome-copilot --skill react19-concurrent-patterns

Or download just the file:

curl -L https://raw.githubusercontent.com/github/awesome-copilot/main/skills/react19-concurrent-patterns/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

React 19 Concurrent Patterns

React 19 introduced new APIs that complement the migration work. This skill covers two concerns:

  1. Preserve existing React 18 concurrent patterns that must not be broken during migration
  2. Adopt new React 19 APIs worth introducing after migration stabilizes

Part 1 Preserve: React 18 Concurrent Patterns That Must Survive the Migration

These patterns exist in React 18 codebases and must not be accidentally removed or broken:

createRoot Already Migrated by the R18 Orchestra

If the R18 orchestra already ran, ReactDOM.render → createRoot is done. Verify it's correct:

// CORRECT React 19 root (same as React 18):
import { createRoot } from 'react-dom/client';
const root = createRoot(document.getElementById('root'));
root.render(
  <React.StrictMode>
    <App />
  </React.StrictMode>
);

useTransition No Migration Needed

useTransition from React 18 works identically in React 19. Do not touch these patterns during migration:

// React 18 useTransition  unchanged in React 19:
const [isPending, startTransition] = useTransition();

function handleClick() {
  startTransition(() => {
    setFilteredResults(computeExpensiveFilter(input));
  });
}

useDeferredValue No Migration Needed

// React 18 useDeferredValue  unchanged in React 19:
const deferredQuery = useDeferredValue(query);

Suspense for Code Splitting No Migration Needed

// React 18 Suspense with lazy  unchanged in React 19:
const LazyComponent = React.lazy(() => import('./LazyComponent'));

function App() {
  return (
    <Suspense fallback={<Spinner />}>
      <LazyComponent />
    </Suspense>
  );
}

Part 2 React 19 New APIs

These are worth adopting in a post-migration cleanup sprint. Do not introduce these DURING the migration stabilize first.

For full patterns on each new API, read:

  • references/react19-use.md the use() hook for promises and context
  • references/react19-actions.md Actions, useActionState, useFormStatus, useOptimistic
  • references/react19-suspense.md Suspense for data fetching (the new pattern)

Migration Safety Rules

During the React 19 migration itself, these concurrent-mode patterns must be left completely untouched:

# Verify nothing touched these during migration:
grep -rn "useTransition\|useDeferredValue\|Suspense\|startTransition" \
  src/ --include="*.js" --include="*.jsx" | grep -v "\.test\."

If the migrator touched any of these files, review the changes the migration should only have modified React API surface (forwardRef, defaultProps, etc.), never concurrent mode logic.

FAQ

What is 'concurrency' in React?

Concurrency is React's way of managing multiple tasks simultaneously, making the user interface more responsive, especially when something time-consuming is happening in the background.

Why shouldn't I use the new React 19 APIs during migration?

It's best to ensure the main upgrade works first. Introducing new features at the same time can complicate troubleshooting if something goes wrong.

What does `grep` do in this context?

The `grep` command is used to search for specific code snippets (like `useTransition`) across all your files. This helps ensure that no important concurrency code parts were unintentionally modified during the upgrade.

Details

Original description by the author

Preserve React 18 concurrent patterns and adopt React 19 APIs (useTransition, useDeferredValue, Suspense, use(), useOptimistic, Actions) during migration.

repo: github/awesome-copilot

Popularity

GitHub stars
40k
Ranking position
#5332
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills