Skip to main content
Agent skill

React Modernization

Upgrade React applications to latest versions, migrate from class components to hooks, and adopt concurrent features. Use when modernizing React codebases, migrating to React Hooks, or upgrading to latest React versions.

Get started

Get the complete skill folder, including its scripts and reference files.

When to use this skill

Use React Modernization when an AI agent needs a reusable SKILL.md workflow for this job: Upgrade React applications to latest versions, migrate from class components to hooks, and adopt concurrent features. Use when modernizing React codebases, migrating to React Hooks, or upgrading to latest React versions.

When not to use it

Skip React Modernization when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.

How to install

Where will you use it?

Install scope
Claude Code folder setup
mkdir -p ~/.claude/skills/react-modernization
# Save SKILL.md to ~/.claude/skills/react-modernization/SKILL.md
  1. Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/react-modernization/SKILL.md. For a shared project, commit the folder at .claude/skills/react-modernization/ instead.
  2. Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
  3. For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.

Full install guide for Claude, Cursor, and Codex →

Try a starter prompt

After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.

Starter prompt
Use the React Modernization skill for this task: Upgrading React applications to latest versions. Confirm any required inputs or files before making changes.

What supports this recommendation?

84/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.

Documentation
92/100
Practical detail
92/100
Source evidence
63/100
Source signals
80/100
Model compatibility evidence
  • claudeuntested

    No model-specific signal or recorded compatibility test was found.

  • chatgptuntested

    No model-specific signal or recorded compatibility test was found.

  • geminiuntested

    No model-specific signal or recorded compatibility test was found.

  • copilotuntested

    No model-specific signal or recorded compatibility test was found.

  • llamauntested

    No model-specific signal or recorded compatibility test was found.

  • perplexityuntested

    No model-specific signal or recorded compatibility test was found.

  • mistraluntested

    No model-specific signal or recorded compatibility test was found.

  • grokuntested

    No model-specific signal or recorded compatibility test was found.

Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.

What this skill does

# React Modernization

Master React version upgrades, class to hooks migration, concurrent features adoption, and codemods for automated transformation.

## When to Use This Skill

- Upgrading React applications to latest versions - Migrating class components to functional components with hooks - Adopting concurrent React features (Suspense, transitions) - Applying codemods for automated refactoring - Modernizing state management patterns - Updating to TypeScript - Improving performance with React 18+ features

## Version Upgrade Path

### React 16 → 17 → 18

**Breaking Changes by Version:**

**React 17:**

- Event delegation changes - No event pooling - Effect cleanup timing - JSX transform (no React import needed)

**React 18:**

- Automatic batching - Concurrent rendering - Strict Mode changes (double invocation) - New root API - Suspense on server

## Class to Hooks Migration

### State Management

```javascript // Before: Class component class Counter extends React.Component { constructor(props) { super(props); this.state = { count: 0, name: "", }; }

increment = () => { this.setState({ count: this.state.count + 1 }); };

render() { return ( <div> <p>Count: {this.state.count}</p> <button onClick={this.increment}>Increment</button> </div> ); } }

// After: Functional component with hooks function Counter() { const [count, setCount] = useState(0); const [name, setName] = useState("");

const increment = () => { setCount(count + 1); };

return ( <div> <p>Count: {count}</p> <button onClick={increment}>Increment</button> </div> ); } ```

### Lifecycle Methods to Hooks

```javascript // Before: Lifecycle methods class DataFetcher extends React.Component { state = { data: null, loading: true };

componentDidMount() { this.fetchData(); }

componentDidUpdate(prevProps) { if (prevProps.id !== this.props.id) { this.fetchData(); } }

componentWillUnmount() { this.cancelRequest(); }

fetchData = async () => { const data = await fetch(`/api/${this.props.id}`); this.setState({ data, loading: false }); };

cancelRequest = () => { // Cleanup };

render() { if (this.state.loading) return <div>Loading...</div>; return <div>{this.state.data}</div>; } }

// After: useEffect hook function DataFetcher({ id }) { const [data, setData] = useState(null); const [loading, setLoading] = useState(true);

useEffect(() => { let cancelled = false;

const fetchData = async () => { try { const response = await fetch(`/api/${id}`); const result = await response.json();

if (!cancelled) { setData(result); setLoading(false); } } catch (error) { if (!cancelled) { console.error(error); } } };

fetchData();

// Cleanup function return () => { cancelled = true; }; }, [id]); // Re-run when id changes

if (loading) return <div>Loading...</div>; return <div>{data}</div>; } ```

### Context and HOCs to Hooks

```javascript // Before: Context consumer and HOC const ThemeContext = React.createContext();

class ThemedButton extends React.Component { static contextType = ThemeContext;

render() { return ( <button style={{ background: this.context.theme }}> {this.props.children} </button> ); } }

// After: useContext hook function ThemedButton({ children }) { const { theme } = useContext(ThemeContext);

return <button style={{ background: theme }}>{children}</button>; }

// Before: HOC for data fetching function withUser(Component) { return class extends React.Component { state = { user: null };

componentDidMount() { fetchUser().then((user) => this.setState({ user })); }

render() { return <Component {...this.props} user={this.state.user} />; } }; }

// After: Custom hook function useUser() { const [user, setUser] = useState(null);

useEffect(() => { fetchUser().then(setUser); }, []);

return user; }

function UserProfile() { const user = useUser(); if (!user) return <div>Loading...</div>; return <div>{user.name}</div>; } ```

## React 18 Concurrent Features

### New Root API

```javascript // Before: React 17 import ReactDOM from "react-dom";

ReactDOM.render(<App />, document.getElementById("root"));

// After: React 18 import { createRoot } from "react-dom/client";

const root = createRoot(document.getElementById("root")); root.render(<App />); ```

### Automatic Batching

```javascript // React 18: All updates are batched function handleClick() { setCount((c) => c + 1); setFlag((f) => !f); // Only one re-render (batched) }

// Even in async: setTimeout(() => { setCount((c) => c + 1); setFlag((f) => !f); // Still batched in React 18! }, 1000);

// Opt out if needed import { flushSync } from "react-dom";

flushSync(() => { setCount((c) => c + 1); }); // Re-render happens here setFlag((f) => !f); // Another re-render ```

### Transitions

```javascript import { useState, useTransition } from "react";

function SearchResults() { const [query, setQuery] = useState(""); const [results, setResults] = useState([]); const [isPending, startTransition] = useTransition();

const handleChange = (e) => { // Urgent: Update input immediately setQuery(e.target.value);

// Non-urgent: Update results (can be interrupted) startTransition(() => { setResults(searchResults(e.target.value)); }); };

return ( <> <input value={query} onChange={handleChange} /> {isPending && <Spinner />} <Results data={results} /> </> ); } ```

### Suspense for Data Fetching

```javascript import { Suspense } from "react";

// Resource-based data fetching (with React 18) const resource = fetchProfileData();

function ProfilePage() { return ( <Suspense fallback={<Loading />}> <ProfileDetails /> <Suspense fallback={<Loading />}> <ProfileTimeline /> </Suspense> </Suspense> ); }

function ProfileDetails() { // This will suspend if data not ready const user = resource.user.read(); return <h1>{user.name}</h1>; }

function ProfileTimeline() { const posts = resource.posts.read(); return <Timeline posts={posts} />; } ```

## Additional patterns and templates

More detailed templates and worked examples live in `references/details.md`. Read that file for the full pattern library.

Intended uses

  • Upgrading React applications to latest versions
  • Migrating class components to functional components with hooks
  • Adopting concurrent React features (Suspense, transitions)
  • Applying codemods for automated refactoring
  • Modernizing state management patterns
  • Updating to TypeScript
  • Improving performance with React 18+ features

Implementation notes

  • Review the source instructions and adapt inputs before running the workflow.

Try it, then tell us how it went

A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.