Agent skill

Inertia React Development

by hexlet-volunteers in hexlet-volunteers/hexlet-sicp

Develops Inertia.js v3 React client-side applications. An agent skill from hexlet-volunteers/hexlet-sicp.

MITAuto-check passedBackend & APIs

Install Inertia React Development

skills CLI
$ npx skills add hexlet-volunteers/hexlet-sicp --skill inertia-react-development -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install hexlet-volunteers/hexlet-sicp inertia-react-development --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/hexlet-volunteers/hexlet-sicp.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/inertia-react-development .claude/skills/inertia-react-development && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
inertia-react-development
GitHub stars
114
Token cost
~3.4k tokens
SKILL.md length
546 words
Files
1
Skills in repo
4
Repo updated
First seen
Licence
MIT

At a glance

Develops Inertia.js v3 React client-side applications. An agent skill from hexlet-volunteers/hexlet-sicp.

  • Mentions React with Inertia
  • SKILL.md covers When to Apply, Documentation, Basic Usage and Client-Side Navigation, plus 4 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
  • React navigation

What it does

Inertia React Development is an agent skill from hexlet-volunteers/hexlet-sicp. Develops Inertia.js v3 React client-side applications. Activates when creating React pages, forms, or navigation; using <Link, <Form, useForm, useHttp, setLayoutProps, or router; working with deferred props, prefetching, optimistic updates, instant visits, or polling; or when user mentions React with Inertia, React pages, React forms, or React navigation.

Its SKILL.md is about 3.4k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Backend & APIs. It works with React. The repository describes itself as: Hexlet SICP is a service for those studying the book Structure and Interpretation of Computer Programs. Track your progress and match yourself against others on the global… The licence is MIT.

When your agent uses it

  • Mentions React with Inertia
  • React navigation

Example prompts

  • “Use the inertia-react-development skill to develop Inertia.js v3 React client-side applications. An agent skill from hexlet-volunteers/hexlet-sicp”
  • “/inertia-react-development”

What it can do on your machine

Read from SKILL.md and the folder at commit 4113c36. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are react).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Inertia React Development loads about 3.4k tokens when it runs. Until then it costs about 96 tokens; SKILL.md has 546 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~96
When it runs · the whole SKILL.md, loaded when a task matches
~3.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from hexlet-volunteers/hexlet-sicp at commit 4113c36, republished under its MIT licence (© hexlet-volunteers). 546 words, ~3,449 tokens.

Download SKILL.mdSave it as .claude/skills/inertia-react-development/SKILL.md (or your agent's skills folder).
name
inertia-react-development
description
Develops Inertia.js v3 React client-side applications. Activates when creating React pages, forms, or navigation; using <Link>, <Form>, useForm, useHttp, setLayoutProps, or router; working with deferred props, prefetching, optimistic updates, instant visits, or polling; or when user mentions React with Inertia, React pages, React forms, or React navigation.
license
MIT
metadata.author
laravel

Inertia React Development

When to Apply

Activate this skill when:

  • Creating or modifying React page components for Inertia
  • Working with forms in React (using <Form>, useForm, or useHttp)
  • Implementing client-side navigation with <Link> or router
  • Using v3 features: deferred props, prefetching, optimistic updates, instant visits, layout props, HTTP requests, WhenVisible, InfiniteScroll, once props, flash data, or polling
  • Building React-specific features with the Inertia protocol

Documentation

Use search-docs for detailed Inertia v3 React patterns and documentation.

Basic Usage

Page Components Location

React page components should be placed in the resources/js/pages directory.

Page Component Structure
<!-- Basic React Page Component -->
react
export default function UsersIndex({ users }) {
    return (
        <div>
            <h1>Users</h1>
            <ul>
                {users.map(user => <li key={user.id}>{user.name}</li>)}
            </ul>
        </div>
    )
}

Client-Side Navigation

Use <Link> for client-side navigation instead of traditional <a> tags:

<!-- Inertia React Navigation -->
react
import { Link, router } from '@inertiajs/react'

<Link href="/">Home</Link>
<Link href="/users">Users</Link>
<Link href={`/users/${user.id}`}>View User</Link>
<!-- Link with POST Method -->
react
import { Link } from '@inertiajs/react'

<Link href="/logout" method="post" as="button">
    Logout
</Link>
Prefetching

Prefetch pages to improve perceived performance:

<!-- Prefetch on Hover -->
react
import { Link } from '@inertiajs/react'

<Link href="/users" prefetch>
    Users
</Link>
Programmatic Navigation
<!-- Router Visit -->
react
import { router } from '@inertiajs/react'

function handleClick() {
    router.visit('/users')
}

// Or with options
router.visit('/users', {
    method: 'post',
    data: { name: 'John' },
    onSuccess: () => console.log('Success!'),
})

Form Handling

The recommended way to build forms is with the <Form> component:

<!-- Form Component Example -->
react
import { Form } from '@inertiajs/react'

export default function CreateUser() {
    return (
        <Form action="/users" method="post">
            {({ errors, processing, wasSuccessful }) => (
                <>
                    <input type="text" name="name" />
                    {errors.name && <div>{errors.name}</div>}

                    <input type="email" name="email" />
                    {errors.email && <div>{errors.email}</div>}

                    <button type="submit" disabled={processing}>
                        {processing ? 'Creating...' : 'Create User'}
                    </button>

                    {wasSuccessful && <div>User created!</div>}
                </>
            )}
        </Form>
    )
}
Form Component With All Props
<!-- Form Component Full Example -->
react
import { Form } from '@inertiajs/react'

<Form action="/users" method="post">
    {({
        errors,
        hasErrors,
        processing,
        progress,
        wasSuccessful,
        recentlySuccessful,
        clearErrors,
        resetAndClearErrors,
        defaults,
        isDirty,
        reset,
        submit
    }) => (
        <>
            <input type="text" name="name" defaultValue={defaults.name} />
            {errors.name && <div>{errors.name}</div>}

            <button type="submit" disabled={processing}>
                {processing ? 'Saving...' : 'Save'}
            </button>

            {progress && (
                <progress value={progress.percentage} max="100">
                    {progress.percentage}%
                </progress>
            )}

            {wasSuccessful && <div>Saved!</div>}
        </>
    )}
</Form>
Form Component Reset Props

The <Form> component supports automatic resetting:

  • resetOnError - Reset form data when the request fails
  • resetOnSuccess - Reset form data when the request succeeds
  • setDefaultsOnSuccess - Update default values on success

Use the search-docs tool with a query of form component resetting for detailed guidance.

<!-- Form with Reset Props -->
react
import { Form } from '@inertiajs/react'

<Form
    action="/users"
    method="post"
    resetOnSuccess
    setDefaultsOnSuccess
>
    {({ errors, processing, wasSuccessful }) => (
        <>
            <input type="text" name="name" />
            {errors.name && <div>{errors.name}</div>}

            <button type="submit" disabled={processing}>
                Submit
            </button>
        </>
    )}
</Form>

Forms can also be built using the useForm helper for more programmatic control. Use the search-docs tool with a query of useForm helper for guidance.

useForm Hook

For more programmatic control or to follow existing conventions, use the useForm hook:

<!-- useForm Hook Example -->
react
import { useForm } from '@inertiajs/react'

export default function CreateUser() {
    const { data, setData, post, processing, errors, reset } = useForm({
        name: '',
        email: '',
        password: '',
    })

    function submit(e) {
        e.preventDefault()
        post('/users', {
            onSuccess: () => reset('password'),
        })
    }

    return (
        <form onSubmit={submit}>
            <input
                type="text"
                value={data.name}
                onChange={e => setData('name', e.target.value)}
            />
            {errors.name && <div>{errors.name}</div>}

            <input
                type="email"
                value={data.email}
                onChange={e => setData('email', e.target.value)}
            />
            {errors.email && <div>{errors.email}</div>}

            <input
                type="password"
                value={data.password}
                onChange={e => setData('password', e.target.value)}
            />
            {errors.password && <div>{errors.password}</div>}

            <button type="submit" disabled={processing}>
                Create User
            </button>
        </form>
    )
}

Inertia v3 Features

HTTP Requests

Use the useHttp hook for standalone HTTP requests that do not trigger Inertia page visits. It provides the same developer experience as useForm, but for plain JSON endpoints.

<!-- useHttp Example -->
react
import { useHttp } from '@inertiajs/react'

export default function Search() {
    const { data, setData, get, processing } = useHttp({
        query: '',
    })

    function search(e) {
        setData('query', e.target.value)
        get('/api/search', {
            onSuccess: (response) => {
                console.log(response)
            },
        })
    }

    return (
        <>
            <input value={data.query} onChange={search} />
            {processing && <div>Searching...</div>}
        </>
    )
}
Optimistic Updates

Apply data changes instantly before the server responds, with automatic rollback on failure:

<!-- Optimistic Update with Router -->
react
import { router } from '@inertiajs/react'

function like(post) {
    router.optimistic((props) => ({
        post: {
            ...props.post,
            likes: props.post.likes + 1,
        },
    })).post(`/posts/${post.id}/like`)
}

Optimistic updates also work with useForm and the <Form> component:

<!-- Optimistic Update with Form Component -->
react
import { Form } from '@inertiajs/react'

<Form
    action="/todos"
    method="post"
    optimistic={(props, data) => ({
        todos: [...props.todos, { id: Date.now(), name: data.name, done: false }],
    })}
>
    <input type="text" name="name" />
    <button type="submit">Add Todo</button>
</Form>
Instant Visits

Navigate to a new page immediately without waiting for the server response. The target component renders right away with shared props, while page-specific props load in the background.

<!-- Instant Visit with Link -->
react
import { Link } from '@inertiajs/react'

<Link href="/dashboard" component="Dashboard">Dashboard</Link>

<Link
    href="/posts/1"
    component="Posts/Show"
    pageProps={{ post: { id: 1, title: 'My Post' } }}
>
    View Post
</Link>
Layout Props

Share dynamic data between pages and persistent layouts:

<!-- Layout Props in Layout -->
react
export default function Layout({ title = 'My App', showSidebar = true, children }) {
    return (
        <>
            <header>{title}</header>
            {showSidebar && <aside>Sidebar</aside>}
            <main>{children}</main>
        </>
    )
}
<!-- Setting Layout Props from Page -->
react
import { setLayoutProps } from '@inertiajs/react'

export default function Dashboard() {
    setLayoutProps({
        title: 'Dashboard',
        showSidebar: false,
    })

    return <h1>Dashboard</h1>
}
Show full SKILL.md (239 more words)Show less
Deferred Props

Use deferred props to load data after initial page render:

<!-- Deferred Props with Empty State -->
react
export default function UsersIndex({ users }) {
    return (
        <div>
            <h1>Users</h1>
            {!users ? (
                <div className="animate-pulse">
                    <div className="h-4 bg-gray-200 rounded w-3/4 mb-2"></div>
                    <div className="h-4 bg-gray-200 rounded w-1/2"></div>
                </div>
            ) : (
                <ul>
                    {users.map(user => (
                        <li key={user.id}>{user.name}</li>
                    ))}
                </ul>
            )}
        </div>
    )
}
Polling

Use the usePoll hook to automatically refresh data at intervals. It handles cleanup on unmount and throttles polling when the tab is inactive.

<!-- Basic Polling -->
react
import { usePoll } from '@inertiajs/react'

export default function Dashboard({ stats }) {
    usePoll(5000)

    return (
        <div>
            <h1>Dashboard</h1>
            <div>Active Users: {stats.activeUsers}</div>
        </div>
    )
}
<!-- Polling With Request Options and Manual Control -->
react
import { usePoll } from '@inertiajs/react'

export default function Dashboard({ stats }) {
    const { start, stop } = usePoll(5000, {
        only: ['stats'],
        onStart() {
            console.log('Polling request started')
        },
        onFinish() {
            console.log('Polling request finished')
        },
    }, {
        autoStart: false,
        keepAlive: true,
    })

    return (
        <div>
            <h1>Dashboard</h1>
            <div>Active Users: {stats.activeUsers}</div>
            <button onClick={start}>Start Polling</button>
            <button onClick={stop}>Stop Polling</button>
        </div>
    )
}
  • autoStart (default true) - set to false to start polling manually via the returned start() function
  • keepAlive (default false) - set to true to prevent throttling when the browser tab is inactive
WhenVisible

Lazy-load a prop when an element scrolls into view. Useful for deferring expensive data that sits below the fold:

<!-- WhenVisible Example -->
react
import { WhenVisible } from '@inertiajs/react'

export default function Dashboard({ stats }) {
    return (
        <div>
            <h1>Dashboard</h1>

            <WhenVisible data="stats" buffer={200} fallback={<div className="animate-pulse">Loading stats...</div>}>
                {({ fetching }) => (
                    <div>
                        <p>Total Users: {stats.total_users}</p>
                        <p>Revenue: {stats.revenue}</p>
                        {fetching && <span>Refreshing...</span>}
                    </div>
                )}
            </WhenVisible>
        </div>
    )
}
InfiniteScroll

Automatically load additional pages of paginated data as users scroll:

<!-- InfiniteScroll Example -->
react
import { InfiniteScroll } from '@inertiajs/react'

export default function Users({ users }) {
    return (
        <InfiniteScroll data="users">
            {users.data.map(user => (
                <div key={user.id}>{user.name}</div>
            ))}
        </InfiniteScroll>
    )
}

The server must use Inertia::scroll() to configure the paginated data. Use the search-docs tool with a query of infinite scroll for detailed guidance on buffers, manual loading, reverse mode, and custom trigger elements.

Server-Side Patterns

Server-side patterns (Inertia::render, props, middleware) are covered in inertia-laravel guidelines.

Common Pitfalls

  • Using traditional <a> links instead of Inertia's <Link> component (breaks SPA behavior)
  • Forgetting to add loading states (skeleton screens) when using deferred props
  • Not handling the undefined state of deferred props before data loads
  • Using <form> without preventing default submission (use <Form> component or e.preventDefault())
  • Forgetting to check if <Form> component is available in your Inertia version
  • Using router.cancel() instead of router.cancelAll() (v3 breaking change)
  • Using router.on('invalid', ...) or router.on('exception', ...) instead of the renamed httpException and networkError events

© hexlet-volunteers, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .agents/skills/inertia-react-development of hexlet-volunteers/hexlet-sicp.

Open the folder on GitHubat commit 4113c36

Compare with similar skills

Inertia React Development next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Inertia React Development compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Inertia React Development this skillhexlet-volunteers/hexlet-sicp114—~3.4kAutomated safety check: PassMIT
Stripe Appsfossasia/eventyay1.7k2 repos~3.6kAutomated safety check: PassApache-2.0
Supabasecurvenote/curvenote1695 repos~2.2kAutomated safety check: PassCustom licence
Twenty Syncable Entity Cache and Transformtwentyhq/twenty58k—~2.4kAutomated safety check: PassCustom licence
Livewire Developmentcoollabsio/coolify63k—~964Automated safety check: PassMIT
NEAR Intents Swap Integrationinternet-court/internet-court-skill6.4k2 repos~939Automated safety check: PassCustom licence

Similar skills

  • Stripe Apps

    fossasia/eventyay

    A skill your agent uses when building, modifying, or reviewing a Stripe App — or when the user describes something that implies one (e.g.

    1.7k GitHub starsUsed in 2 repos~3.6k tokens
    Backend & APIsAuto-check passed
  • Supabase

    curvenote/curvenote

    A skill your agent uses when doing ANY task involving Supabase.

    169 GitHub starsUsed in 5 repos~2.2k tokens
    Backend & APIsAuto-check passed
  • Walks through step 2 of adding a syncable entity to the Twenty server: a cache service for flat entity maps and utilities that transform entities and DTOs into universal flat entities.

    58k GitHub stars~2.4k tokensUpdated today
    Backend & APIsAuto-check passed
  • Livewire Development

    coollabsio/coolify

    A skill your agent uses for any task or question involving Livewire.

    63k GitHub stars~964 tokensUpdated yesterday
    Backend & APIsAuto-check passed
  • NEAR Intents Swap Integration

    internet-court/internet-court-skill

    Builds cross-chain token swaps and bridge flows with the NEAR Intents 1Click API: quotes, deposit addresses, per-chain deposits and status polling.

    6.4k GitHub starsUsed in 2 repos~939 tokens
    Backend & APIsAuto-check passed
  • Trigger.dev Realtime

    papermark/papermark

    Shows how to subscribe to Trigger.dev task runs from the backend and from React for progress indicators, live dashboards, AI response streams and approval waits.

    9.2k GitHub stars~1.7k tokensUpdated 1 mo ago
    Backend & APIsAuto-check passed

More from hexlet-volunteers/hexlet-sicp

  • Debug Using Debugbar

    hexlet-volunteers/hexlet-sicp

    Inspect what a Laravel request actually did — queries, exceptions, timing, cache, auth, views — by reading the profiling data Laravel Debugbar already captured, via Artisan commands.

    114 GitHub starsUsed in 1 repo~1.5k tokens
    Auto-check passed
  • Socialite Development

    hexlet-volunteers/hexlet-sicp

    Manages OAuth social authentication with Laravel Socialite. An agent skill from hexlet-volunteers/hexlet-sicp.

    114 GitHub starsUsed in 5 repos~1.2k tokens
    Auto-check passed
  • Laravel Query Builder

    hexlet-volunteers/hexlet-sicp

    Build filtered, sorted, and included API endpoints using spatie/laravel-query-builder.

    114 GitHub stars~2.4k tokensUpdated 3 days ago
    Auto-check passed

Works with

Categories

Questions about Inertia React Development

What does Inertia React Development do?

Develops Inertia.js v3 React client-side applications. An agent skill from hexlet-volunteers/hexlet-sicp. Inertia React Development is an agent skill from hexlet-volunteers/hexlet-sicp.js v3 React client-side applications.

When should I use Inertia React Development?

Inertia React Development fits situations like: mentions React with Inertia; React navigation.

How do I install Inertia React Development in Claude Code?

Run `npx skills add hexlet-volunteers/hexlet-sicp --skill inertia-react-development -a claude-code`. Or copy the skill folder (.agents/skills/inertia-react-development in hexlet-volunteers/hexlet-sicp) into .claude/skills/inertia-react-development in your project. Claude Code loads it when a task matches its description.

How do I install Inertia React Development in Codex?

Run `npx skills add hexlet-volunteers/hexlet-sicp --skill inertia-react-development -a codex`. Or copy the skill folder (.agents/skills/inertia-react-development in hexlet-volunteers/hexlet-sicp) into .agents/skills/inertia-react-development in your project. Codex loads it when a task matches its description.

Can I use Inertia React Development in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add hexlet-volunteers/hexlet-sicp --skill inertia-react-development -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/inertia-react-development, .gemini/skills/inertia-react-development, .github/skills/inertia-react-development and .opencode/skills/inertia-react-development in your project.

What does Inertia React Development need to run?

SKILL.md names no scripts, command-line tools or credentials: Inertia React Development is instructions for the agent only.

Does Inertia React Development access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Inertia React Development safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Inertia React Development use?

Inertia React Development is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Inertia React Development use?

About 3.4k tokens (SKILL.md is roughly 14k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Inertia React Development?

Skills that share tags, products or a category with Inertia React Development: Stripe Apps (fossasia/eventyay, 1.7k stars), Supabase (curvenote/curvenote, 169 stars), Twenty Syncable Entity Cache and Transform (twentyhq/twenty, 58k stars) and Livewire Development (coollabsio/coolify, 63k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Inertia React Development?

hexlet-volunteers (a GitHub organization) maintains it in hexlet-volunteers/hexlet-sicp, which has 114 GitHub stars. The repository holds 4 skills in this directory. The repository was last updated on October 5, 2026.

Source: hexlet-volunteers/hexlet-sicp on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.