Skip to main content
skill CX Codex

refine-dev — Claude Code skill: Refine CRUD apps

refine-dev — a skill that gives the agent Refine's data provider, resource and hook model, so React admin panels over REST, GraphQL, Supabase or Strapi get built the intended way.

MIT 210 installs ★ 23 updated 2026-10-24

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add itechmeat/llm-code --skill refine-dev -a claude-code
Open on GitHub

What refine-dev does

The skill hands the agent a map of Refine's core pieces: a backend adapter, declared resources, hooks, an auth provider and a router provider. Reference files sit beside it, covering data providers, resources, routing, hooks, auth, Mantine UI, the inferencer, notifications, i18n and realtime. Since 5.0.12, useList and useTable keep extra fields that getList returns.

Scaffolding runs through npm create refine-app@latest with Vite, Mantine and a REST backend, or the packages go in by hand. A feature then follows a fixed order: declare the entity in <Refine resources={[...]}>, write the List, Create, Edit and Show pages, match routes to resource paths, and reach for useTable on lists and useForm on create and edit screens.

A section called Critical Prohibitions keeps the agent in line. One UI library per project, Mantine if that is what you started with. Reads and writes go through Refine hooks instead of raw fetches, API addresses stay in the data provider config, and every CRUD entity appears in resources.

What it helps with

  • build a React admin panel over REST or GraphQL
  • wire Supabase or Strapi in as a data provider
  • set up login and permissions with an auth provider
  • generate CRUD pages from an API schema with the inferencer
  • subscribe to live updates through LiveProvider

Example prompts for the agent

  • Scaffold a Refine admin panel for posts with Mantine and a REST data provider.
  • Why does useTable drop the extra field my getList returns?
  • Add an auth provider that checks user roles.

How to install refine-dev

1Skills CLI (Vercel)

npx skills add itechmeat/llm-code --skill refine-dev -a claude-code

2Manually: put the files in place

~/.claude/skills/refine-dev/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/refine-dev/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about refine-dev

How do I install refine-dev in Claude Code?

Run npx skills add itechmeat/llm-code --skill refine-dev -a claude-code. The skill lands at ~/.claude/skills/refine-dev/SKILL.md.

What does refine-dev do?

It briefs the agent on Refine's building blocks: data providers, resources, hooks, auth and router providers. Separate reference files cover the inferencer, i18n, realtime and notifications.

Does Refine ship a ready-made UI?

It is headless: CRUD logic comes from the framework, the interface comes from a library you add, Mantine in this skill's examples. Mixing two UI libraries in one app is ruled out.

Source text

SKILL.md · MIT
---
name: refine-dev
description: "Refine.dev headless React framework for CRUD apps: data providers, resources, routing, authentication, hooks, and forms. Use when building admin panels, dashboards, or internal tools with React and various backends (REST, GraphQL, Supabase, Strapi), or configuring Refine data providers and authentication. Keywords: Refine, CRUD, admin panel, data provider, React."
metadata:
  version: "5.0.12"
  release_date: "2026-04-02"
---

# Refine.dev Framework

Refine is a headless React framework for building enterprise CRUD applications. It provides data fetching, routing, authentication, and access control out of the box while remaining UI-agnostic.

## Core Concepts

Refine is built around these key abstractions:

1. **Data Provider** — adapter for your backend (REST, GraphQL, etc.)
2. **Resources** — entities in your app (e.g., `posts`, `users`, `products`)
3. **Hooks** — `useList`, `useOne`, `useCreate`, `useUpdate`, `useDelete`, `useForm`, `useTable`
4. **Auth Provider** — handles login, logout, permissions
5. **Router Provider** — integrates with React Router, etc.

## Quick Start (Vite)

Scaffold: `npm create refine-app@latest` (select Vite, Mantine, REST API). For manual setup, install `@refinedev/core @refinedev/mantine @refinedev/react-router` and Mantine packages.

## Minimal App Structure

```tsx
// src/App.tsx
import { Refine } from "@refinedev/core";
import { MantineProvider } from "@mantine/core";
import routerProvider from "@refinedev/react-router";
import dataProvider from "@refinedev/simple-rest";
import { BrowserRouter, Routes, Route } from "react-router-dom";

function App() {
  return (
    <BrowserRouter>
      <MantineProvider>
        <Refine
          dataProvider={dataProvider("https://api.example.com")}
          routerProvider={routerProvider}
          resources={[
            {
              name: "posts",
              list: "/posts",
              create: "/posts/create",
              edit: "/posts/edit/:id",
              show: "/posts/show/:id",
            },
          ]}
        >
          <Routes>{/* Your routes here */}</Routes>
        </Refine>
      </MantineProvider>
    </BrowserRouter>
  );
}
```

## Critical Prohibitions

- Do NOT mix multiple UI libraries (pick Mantine and stick with it)
- Do NOT bypass data provider — always use Refine hooks for data operations
- Do NOT hardcode API URLs — use data provider configuration
- Do NOT skip resource definition — all CRUD entities must be declared in `resources`
- Do NOT ignore TypeScript types — Refine is fully typed, leverage it

## Steps for New Feature

1. Define the resource in `<Refine resources={[...]}>`
2. Create page components (List, Create, Edit, Show)
3. Set up routes matching resource paths
4. Use appropriate hooks (`useTable` for lists, `useForm` for create/edit)
5. Configure auth provider if authentication is needed

## Definition of Done

- [ ] Resource defined in Refine configuration
- [ ] All CRUD pages implemented with proper hooks
- [ ] Routes match resource configuration
- [ ] TypeScript types for resource data defined
- [ ] Error handling in place
- [ ] Loading states handled

## Release Note (5.0.12)

- `useList` and `useTable` now preserve custom fields returned by `getList`, which matters when your data provider returns extra aggregate or pagination metadata alongside the row list.

## References (Detailed Guides)

### Core

- [data-providers.md](references/data-providers.md) — Data provider interface, available providers, custom implementation
- [resources.md](references/resources.md) — Resource definition and configuration
- [routing.md](references/routing.md) — React Router integration and route patterns

### Hooks

- [hooks.md](references/hooks.md) — All hooks: useList, useOne, useCreate, useUpdate, useDelete, useForm, useTable, useSelect

### Security & Auth

- [auth.md](references/auth.md) — Auth provider, access control, RBAC/ABAC, Casbin/CASL integration

### UI & Components

- [mantine-ui.md](references/mantine-ui.md) — Mantine components integration
- [inferencer.md](references/inferencer.md) — Auto-generate CRUD pages from API schema

### Utilities & Features

- [notifications.md](references/notifications.md) — Notification provider and useNotification hook
- [i18n.md](references/i18n.md) — Internationalization with i18nProvider
- [realtime.md](references/realtime.md) — LiveProvider for websocket/realtime subscriptions

## Links

- [Documentation](https://refine.dev/docs/)
- [Releases](https://github.com/refinedev/refine/releases)
- [GitHub](https://github.com/refinedev/refine)
- [npm](https://www.npmjs.com/package/@refinedev/core)

© itechmeat · MIT · itechmeat/llm-code

Similar skills

All skills for Frontend and UI →
modern-web-development Mindrally modern-web-development — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that enforces TypeScript and Next.js 14 coding standards across a project. CX Codex +1 1,300installs cloud assistant-ui Wires AssistantCloud into an assistant-ui app for cross-session thread history, message feedback and file uploads. CX Codex +1 5,300installs bencium-code-conventions bencium bencium-code-conventions sets Bence's conventions for React and Next.js projects, covering the stack, code style, tests and workflow. Use it when building or setting up work under those rules. CX Codex +1 3,500installs nextjs-typescript-tailwindcss-supabase Mindrally nextjs-typescript-tailwindcss-supabase — a skill that steers your agent toward Next.js 14, TypeScript, TailwindCSS and Supabase: server components, error handling, readable code. CX Codex +1 1,400installs typescript-react-nextui-supabase-cursorrules-promp PatrickJS The typescript-react-nextui-supabase-cursorrules-promp rule gives an agent context for a TypeScript app built with React, NextUI, and Supabase. Use it when working on the UI, user dashboard, or authentication flows. CX Codex +1 ★ 41,178repo stars typescript-nextjs-supabase-cursorrules-prompt-file PatrickJS typescript-nextjs-supabase-cursorrules-prompt-file — a Cursor rule that keeps TypeScript work on Next.js App Router and Supabase consistent: server components first, Shadcn UI, Tailwind. CX Codex +1 ★ 41,178repo stars

From the same set16

The whole set →

Project sponsors

Companies that keep this analytics open