Guidelines for writing consistent React components, choosing the right UI primitives, and applying modular styling.

Install

mkdir -p .claude/skills/react && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/627" && unzip -o skill.zip -d .claude/skills/react && rm skill.zip

Installs to .claude/skills/react

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

LobeHub React component conventions. Use when editing TSX UI, choosing base-ui vs @lobehub/ui vs antd, styling with antd-style, routing, desktop variants, layouts, or component state.
183 chars✓ has a “when” trigger
Intermediate

Key capabilities

  • →Develop React components using TSX
  • →Select appropriate UI primitives from base-ui or antd
  • →Implement styling with createStaticStyles
  • →Manage routing with react-router-dom
  • →Sync desktop variants for Electron

How it works

The skill enforces a component hierarchy that prioritizes headless base-ui primitives over higher-level wrappers, ensuring consistent styling and state management.

Inputs & outputs

You give it
UI component requirements
You get back
React component code

When to use react

  • →Create a new UI component
  • →Implement component styling
  • →Select appropriate UI primitives
  • →Refactor component structure

About this skill

React Component Writing Guide

Styling

ScenarioApproach
Files already on StyleX, and new SPA stylesstylex.create + @lobehub/ui/stylex/cssVar.stylex / @lobehub/ui/stylex/media.stylex. The SPA compiler is plugins/vite/stylex.ts (@stylexjs/unplugin, prefix lh). Do not copy those token modules into the app.
Existing styles not yet migratedcreateStaticStyles + cssVar.* (zero-runtime, module-level)
Simple one-offInline style attribute
Truly dynamic (JS color fns like readableColor/chroma)createStyles + token — last resort

StyleX

  • New code may not import createStaticStyles / createStyles / css / keyframes / createGlobalStyle / injectGlobal from @lobehub/ui (stylex-migration/no-emotion-styles). Files still on them are listed in scripts/stylexMigration/legacyFiles.json; after migrating one, run bun run stylex:migration --prune-legacy. Never add entries.
  • New code may not import a plain .css file either (stylex-migration/no-plain-css; CSS modules and package stylesheets are fine). Files that already do are listed in scripts/stylexMigration/plainCssImporters.json, which only shrinks.
  • Migrate a whole file at once. StyleX longhand rules carry raised specificity (.x:not(#\#)) and beat emotion classes on the same element, but StyleX shorthand rules do not, so a half-migrated element resolves by property.
  • Element that also forwards a caller's className / style: {...sx(styles.root, active && styles.active, className, style)} from @/styles/sx. Arguments are variadic like stylex.props: strings become class names and plain objects merge into the inline style, so pass only what you have (sx(styles.bg, { backgroundImage })), never an array or an undefined placeholder. Spreading stylex.props next to className fails @stylexjs/no-conflicting-props.
  • Component that lets callers restyle it: take xstyle?: StyleXStyles and pass it last in the sx / stylex.props array. A plain className from outside cannot override StyleX rules. Passing a class to @lobehub/ui components (className, classNames) works, because lobe-ui CSS sits in @layer lobe-ui.
  • Values follow @stylexjs/valid-styles: no multi-value shorthands (margin: '0 8px' → marginBlock / marginInline), and string flex (flex: '1').
  • background, animation, border and border{Top,Right,Bottom,Left} shorthands compile to no class at all, whatever the value (border: 'none' included), without an error. Write longhands: backgroundColor (plus backgroundImage: 'none' when replacing a background shorthand), animationName / animationDuration / …, borderWidth / borderStyle / borderColor.
  • Traps that compile cleanly but render differently from the emotion original (each one shipped in the migration stack):
    • all: 'unset' compiles to nothing. Write the resets out (appearance, margin, padding, border*, font: 'inherit', textAlign, …).
    • Keep reset semantics: outline: none → outline: 'none' (not outlineStyle); border: 0 → borderWidth: 0 + borderStyle: 'none' + borderColor: 'currentcolor'; font: inherit → font: 'inherit', not a few font longhands; reduced-motion animation: none → reset animationName, animationDuration, animationTimingFunction, animationIterationCount (and animationFillMode if set). Inside stylex.keyframes, background compiles to an empty frame: use backgroundColor.
    • Longhands always beat shorthands, whatever the order: paddingBlockStart beats paddingBlock, flexShrink beats flex. Two overlapping shorthands (borderWidth: 0 with borderInlineWidth: '1px') do not layer either: write disjoint ones (borderBlockWidth + borderInlineWidth). Merged styles must write a property at the same level.
    • Order: lobe-ui cx(a, b) calls emotion.cx, which merges classes from the same emotion cache in argument order (last wins), the same as stylex.props(a, b). Only what it cannot merge (plain strings, StyleX classes, another cache) falls back to stylesheet order. Keep the original argument order unless the base actually renders otherwise.
    • A per-property map replaces the whole map: a state style (active, selected) that sets backgroundColor wipes an earlier ':hover' on it, and { default: null, ':hover': x } wipes an earlier style's default. Carry both: { default: <state>, ':hover': <hover> }.
    • Dynamic StyleX functions carry their values in an inline style: spread stylex.props(fn(x)) or use sx, never .className alone. StyleX objects passed into cx() vanish.
    • Keep physical edges and corners when the original used them (border-radius: 0 r r 0 → borderTopRightRadius …); logical properties flip in RTL.
    • Strict media ranges: 620px < width compiles to width >= 620.01px, which Chrome matches at a 620px viewport. For disjoint ranges write 620.02px <= width.
    • Do not add declarations the original did not have (a transition on an element nothing animates).
    • stylex.when.ancestor(...) without a marker listens to every ancestor carrying stylex.defaultMarker(), including unrelated wrappers (a scroll container, a layout cell). For a hover / focus reveal give the owner a private stylex.defineMarker() from a markers.stylex.ts beside it.
    • stylex.when.siblingBefore(...) compiles to the general sibling combinator ~, not +, and only sees siblings that carry the marker. It reproduces & + & only when the matching siblings are always contiguous and marked; otherwise pass an explicit prop (divided, index > 0).
    • Keep !important when the competitor is an inline style: lobe-ui writes some properties inline (ActionIcon / Avatar with a numeric size → borderRadius, width; Image → maxWidth). Without it the inline value wins; pass the value through the component's style instead.
    • A caller's StyleX className passed through className into a component that applies its own StyleX on the same property gives one element two atomic classes for it, and the build's sort order (not argument order) picks the winner. Restyle our own components through an xstyle prop merged last.
  • Check a migration in dev with the DevDock snapshot helper: on the migrated page run __lobeStyleSnapshot.capture('<name>', '<root selector>'), back up the migrated files with their relative paths into a fresh directory (BACKUP=$(mktemp -d) && rsync -R <paths> "$BACKUP/"), swap in the originals (git checkout HEAD -- <paths>), reload, run __lobeStyleSnapshot.compare('<name>'), then restore the migrated files (cp -R "$BACKUP"/. ./). Do not use git stash: every checkout shares one stash stack, and a push with nothing to save creates no entry, so the next pop applies an older one. Each pair reads [captured, current], here [migrated, original]. It lists elements and ::before / ::after whose tracked computed styles, box (relative to the root) or text differ; an empty list means those match, not that hover, focus or closed dialogs were checked, so open each state you migrated and compare it too. Keep the window size, scroll everything under the root back to the start, and move the pointer off the compared area.
  • bun run stylex:migration --list <A|B|C|D> lists files by how hard they are to move: A flat, B self pseudo-classes, C descendant / ancestor coupling (use stylex.defaultMarker() + stylex.when.ancestor() or xstyle), D tag / third-party DOM selectors (see the next rule).
  • Never move a selector into a plain .css file to escape StyleX. Reach the element through an API instead, in this order:
    1. The component's slot props. lobe-ui components take classNames / styles per part, e.g. Tabs → classNames={{ list: stylex.props(styles.tabList).className, tab: stylex.props(styles.tab).className }}.
    2. A pseudo-class on the slot's element: StyleX compiles keys like ':has([data-replace-all])' and ':nth-child(2)', so .tabs [role=tab]:has([data-replace-all]) becomes classNames.tab with marginInlineStart: { default: null, ':has([data-replace-all])': 'auto' }.
    3. Our own component: add an xstyle?: StyleXStyles prop (or <part>Xstyle for an inner part) and apply it there.
    4. Only DOM no prop can reach (editor content such as .ProseMirror p, rendered markdown, third-party widgets, lobe-ui parts without a slot) keeps its original nested rule, unchanged, in a createStaticStyles object in the same file, merged onto the host element with {...sx(styles.content, fallback.content)}. Put // oxlint-disable-next-line stylex-migration/no-emotion-styles -- <what no prop reaches> above the @lobehub/ui import. Add a missing slot to lobe-ui instead when the component is ours.

Component Priority

  1. src/components — project-specific reusable components

Content truncated.

When not to use it

  • →Do not use next/link for SPA navigation
  • →Avoid antd Spin component for loading

Prerequisites

React development environment

Limitations

  • →Requires manual sync of desktop variant files
  • →Strict import hierarchy must be followed

How it compares

It mandates specific architectural patterns and sync rules for desktop variants that generic React guides do not address.

Compared to similar skills

react side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
react (this skill)345moNo flagsIntermediate
zustand1135moNo flagsIntermediate
react-component-patterns34moNo flagsIntermediate
zustand-5810moNo flagsBeginner

Try saying

Example prompts that trigger this skill in your AI assistant.

drizzle

lobehub

Drizzle ORM schema and database guide. Use when working with database schemas (src/database/schemas/*), defining tables, creating migrations, or database model code. Triggers on Drizzle schema definition, database migrations, or ORM usage questions.

238873

zustand

lobehub

Zustand state management guide. Use when working with store code (src/store/**), implementing actions, managing state, or creating slices. Triggers on Zustand store development, state management questions, or action implementation.

113434

typescript

lobehub

TypeScript code style and optimization guidelines. Use when writing TypeScript code (.ts, .tsx, .mts files), reviewing code quality, or implementing type-safe patterns. Triggers on TypeScript development, type safety questions, or code style discussions.

2877

project-overview

lobehub

Complete project architecture and structure guide. Use when exploring the codebase, understanding project organization, finding files, or needing comprehensive architectural context. Triggers on architecture questions, directory navigation, or project overview needs.

1548

linear

lobehub

Linear issue management guide. Use when working with Linear issues, creating issues, updating status, or adding comments. Triggers on Linear issue references (LOBE-xxx), issue tracking, or project management tasks. Requires Linear MCP tools to be available.

10117

desktop

lobehub

Electron desktop development guide. Use when implementing desktop features, IPC handlers, controllers, preload scripts, window management, menu configuration, or Electron-specific functionality. Triggers on desktop app development, Electron IPC, or desktop local tools implementation.

941

Search skills

Search the agent skills registry