Skip to content
Skills Library
Programming · Building & coding

component-design

/component-design

Create or restructure a UI component — architecture, component patterns, accessibility, design-system rules. Use when adding a new component, splitting a large one, or making one reusable. App-level work belongs to frontend-ui-engineering.

Repository
claude-kit ↗
Licence
MIT
Last repository change
07.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 07.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Create or restructure a UI component — architecture, component patterns, accessibility, design-system rules. Use when adding a new component, splitting a large one, or making one reusable. App-level work belongs to frontend-ui-engineering.

Arguments

/component-design [component name and purpose]
Original author description

Create or restructure a UI component — architecture, component patterns, accessibility, design-system rules. Use when adding a new component, splitting a large one, or making one reusable. App-level work belongs to frontend-ui-engineering.

How it works

  1. Steps
  2. References
  3. Examples
Original SKILL.md headings · 166 lines, 757 words
SKILL.md preview
---
name: component-design
description: Create or restructure a UI component — architecture, component patterns, accessibility, design-system rules. Use when adding a new component, splitting a large one, or making one reusable. App-level work belongs to frontend-ui-engineering.
argument-hint: '[component name and purpose]'
disable-model-invocation: true
---

Design and implement the component: $ARGUMENTS.

## Steps

1. **Read the design system**: Read `.claude/rules/ui-design-system.md` (foundations & index) and `.claude/rules/ui-components.md` (component standards — cards, badges, buttons, form controls, compound components), both installed as React overlay rules — or a project's `docs/references/ui/ui-design-system.md` equivalent. Read whichever is present.

2. **Check existing components**: Check the project's component directory for available UI primitives and established patterns. Search for similar components to follow the project's conventions.

3. **Determine component type**:

   | Type | Location | Naming | Export |
   |------|----------|--------|--------|
   | UI primitive | Project's UI primitives directory | Follow project naming convention | Add to barrel export if applicable |
   | Compound component | Project's UI primitives directory | Follow project naming convention | Add to barrel export if applicable |
   | Feature component | Project's feature directory | Follow project naming convention | Named export |
   | Page sub-component | Same file as page or shared directory | Follow project naming convention | Not exported |

4. **Design the component API**:

   ### Props/Interface Design Checklist
   - Use the project's type system for component interfaces
   - Required props first, optional props after
   - Use the project's composition pattern (children prop, slots, etc.)
   - Support style extension (className, style, css prop, etc.)
   - Event handlers: consistent naming convention (`on<Event>`, `handle<Event>`, etc.)
   - Use discriminated unions or enums for variant props
   - No boolean prop overload — use string union types or enums for variants

   ### Example (TypeScript/React-style)
   ```tsx
   interface MetricCardProps {
     title: string;
     value: string | number;
     trend?: { direction: 'up' | 'down' | 'flat'; percentage: number };
     status?: 'green' | 'amber' | 'red';
     className?: string;
     onClick?: () => void;
   }
   ```

   ### Example (Template-based framework style)
   ```vue
   interface Props {
     title: string
     value: string | number
     trend?: { direction: 'up' | 'down' | 'flat'; percentage: number }
     status?: 'green' | 'amber' | 'red'
   }
   ```

5. **Implement following these rules**:

   ### Structure
   - Follow the project's import ordering conventions
   - Type definitions near the top
   - Hooks/lifecycle methods in consistent order
   - Derived values and computed properties
   - Event handlers
   - Early returns for loading, empty, and error states
   - Main render/template

   ### Compound Component Pattern
   When building a compound component (e.g., `Card`, `DetailPanel`):
   - Parent component provides shared context
   - Sub-components consume context or accept explicit props
   - Usage: compose sub-components within parent wrapper

   Example:
   ```
   <Card>
     <CardHeader>Title</CardHeader>
     <CardContent>Body</CardContent>
   </Card>
   ```

   ### Accessibility Requirements
   - All interactive elements are keyboard-accessible
   - Icon-only buttons have accessible labels (aria-label, title, etc.)
   - Form inputs have associated labels
   - Use semantic HTML or equivalent (`nav`, `main`, `section`, `article`, `button`, etc.)
   - Focus management: visible focus indicators
   - Use the project's UI library for complex interactions (dialogs, selects, dropdowns, tabs)

6. **Register the component**: If it's a UI primitive or compound component, add it to the project's barrel export or component registry.

7. **Verify**: Run the project's linter, type checker, and build to confirm all checks pass.

## References

- UI primitives: Project's UI primitives directory/barrel export
- Design system: `.claude/rules/ui-design-system.md` (foundations) + `.claude/rules/ui-components.md` + `.claude/rules/ui-layout-and-motion.md` (React overlay) or `docs/references/ui/ui-design-system.md` (if present)
- UX patterns: `.claude/rules/ux-patterns.md` + `.claude/rules/ux-dashboard-patterns.md` (React overlay) or `docs/references/ui/ux-patterns.md` (if present)
- Rules: `.claude/rules/frontend-best-practices.md`, `.claude/rules/responsive-and-accessibility.md`

## Examples

The following examples use React/TypeScript syntax, but the principles apply to any component-based framework. Adapt patterns to your project's stack (Vue, Svelte, Angular, etc.).

### Simple presentational component
```tsx
import { cn } from '@/lib/utils';
import { Badge } from '@/components/ui';

interface StatusIndicatorProps {
  status: 'green' | 'amber' | 'red';
  label: string;
  className?: string;
}

export function StatusIndicator({ status, label, className }: StatusIndicatorProps) {
  return (
    <div className={cn('flex items-center gap-2', className)}>
      <span className={cn('w-2 h-2 rounded-full', {
        'bg-green-500': status === 'green',
        'bg-amber-500': status === 'amber',
        'bg-red-500': status === 'red',
      })} />
      <Badge variant={status === 'red' ? 'destructive' : status === 'amber' ? 'warning' : 'success'}>
        {label}
      </Badge>
    </div>
  );
}
```

### Interactive component with UI library
```tsx
import * as Dialog from '@radix-ui/react-dialog';
import { Button } from '@/components/ui';
import { X } from 'lucide-react';

interface ConfirmDialogProps {
  title: string;
  description: string;
  onConfirm: () => void;
  trigger: React.ReactNode;
}

export function ConfirmDialog({ title, description, onConfirm, trigger }: ConfirmDialogProps) {
  return (
    <Dialog.Root>
      <Dialog.Trigger asChild>{trigger}</Dialog.Trigger>
      <Dialog.Portal>
        <Dialog.Overlay className="fixed inset-0 bg-black/40" />
        <Dialog.Content className="fixed top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 bg-white rounded-lg p-4 w-full max-w-md">
          <Dialog.Title className="text-sm font-semibold text-gray-900">{title}</Dialog.Title>
          <Dialog.Description className="text-sm text-gray-500 mt-2">{description}</Dialog.Description>
          <div className="flex justify-end gap-3 mt-4">
            <Dialog.Close asChild>
              <Button variant="ghost" size="sm">Cancel</Button>
            </Dialog.Close>
            <Button size="sm" onClick={onConfirm}>Confirm</Button>
          </div>
          <Dialog.Close asChild>
            <button className="absolute top-3 right-3" aria-label="Close">
              <X className="w-4 h-4 text-gray-400" />
            </button>
          </Dialog.Close>
        </Dialog.Content>
      </Dialog.Portal>
    </Dialog.Root>
  );
}
```

Versions

RepositoryScoreLicence
This page · ajyadav013/claude-kit100MIT
ajyadav013/claude-kit100MIT
ronraisch/ron-raisch-data-science-skills90MIT

Database snapshot: 13.11.2026 · package version 1d0075a4d7d9 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90frontend-patterns
    Frontend development patterns and best practices. Use for component architecture, state management, CSS patterns, accessibility, performance optimization, and design system integration.
  • 95frontend-component
    Create React/Vue component with TypeScript, tests, and styles. Auto-invoke when user says "create component", "add component", "new component", or "build component".
  • 100web-component-design
    Master React, Vue, and Svelte component patterns including CSS-in-JS, composition strategies, and reusable component architecture. Use when building UI component libraries, designing component APIs, or implementing frontend design systems.
  • 100web-component-design
    Master React, Vue, and Svelte component patterns including CSS-in-JS, composition strategies, and reusable component architecture. Use when building UI component libraries, designing component APIs, or implementing frontend design systems.
  • 90frontend-ui-engineering
    Component architecture, design systems, state management, responsive design, WCAG 2.1 AA accessibility. Use when building or modifying user-facing interfaces.
  • 100frontend-ui-engineering
    Front-load UI construction decisions — component boundary and prop API, state placement, required states, responsiveness, accessibility. Use when creating or refactoring a component, page, or design-system primitive. Don't use for pure logic (/tdd), throwaway exploration…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.