Skip to main content
skill CX Codex

component-template-generator — Claude Code skill: install guide

component-template-generator is a Claude Code skill that creates React, Vue, and Svelte component templates using design tokens. It runs for component-library work and design-system implementation.

MIT 139 installs ★ 274 updated 2026-09-06

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add curiositech/some_claude_skills --skill component-template-generator -a claude-code
Open on GitHub

What component-template-generator does

The skill generates starter components with styling variants and accessibility patterns. Templates refer to semantic design tokens rather than fixed color values. Examples cover buttons, inputs, cards, dialogs, and tabs.

React templates include Tailwind and CSS-variable options; Vue uses the Composition API, while Svelte has its own component syntax. The generated patterns cover keyboard navigation, focus, and ARIA, with details varying by component. The skill uses Read, Write, and Glob.

What it helps with

  • create a starter component in React, Vue, or Svelte
  • add size and state variants to a component
  • style components with design tokens
  • include keyboard navigation and ARIA attributes

Example prompts for the agent

  • Create a React button with primary and secondary variants using design tokens.
  • Generate a Vue dialog component with focus management and ARIA.
  • Make a Svelte tabs template with arrow-key navigation.

How to install component-template-generator

1Skills CLI (Vercel)

npx skills add curiositech/some_claude_skills --skill component-template-generator -a claude-code

2Manually: put the files in place

~/.claude/skills/component-template-generator/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/component-template-generator/

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

Questions about component-template-generator

How do I install component-template-generator in Claude Code?

Run npx skills add curiositech/some_claude_skills --skill component-template-generator -a claude-code. The skill file is at ~/.claude/skills/component-template-generator/SKILL.md.

What does component-template-generator do?

It generates React, Vue, and Svelte component templates that use design tokens and include styling variants and accessibility patterns.

Which frameworks does component-template-generator support?

Its templates cover React, Vue 3 with the Composition API, and Svelte. React examples use either Tailwind or CSS variables.

Source text

SKILL.md · MIT
---
name: component-template-generator
description: Generates starter component code using design tokens. Creates React/Vue/Svelte components with proper token usage, variants, and accessibility built in.
allowed-tools: Read,Write,Glob
metadata:
  category: Development
  pairs-with:
  - skill: design-system-generator
    reason: Uses generated tokens in component code
  - skill: frontend-developer
    reason: Implement and customize generated components
  - skill: design-system-documenter
    reason: Document generated components
  tags:
  - components
  - react
  - vue
  - svelte
  - templates
---

# Component Template Generator

Create production-ready component code that properly uses your design tokens. Generates React, Vue, or Svelte components with variants, accessibility, and token integration.

## Quick Start

**Minimal example - generate a Button component:**

```typescript
// Input: Trend ID + Component type
// Output: Complete component with token usage

// Button.tsx (neobrutalism)
import { cn } from '@/lib/utils';

interface ButtonProps {
  variant?: 'primary' | 'secondary' | 'ghost';
  size?: 'sm' | 'md' | 'lg';
  children: React.ReactNode;
}

export function Button({ variant = 'primary', size = 'md', children }: ButtonProps) {
  return (
    <button className={cn(
      'border-3 border-brutal-black font-display transition-all duration-100',
      'shadow-brutal hover:shadow-brutal-hover hover:-translate-x-0.5 hover:-translate-y-0.5',
      'active:shadow-brutal-active active:translate-x-0.5 active:translate-y-0.5',
      // Variants
      variant === 'primary' && 'bg-brutal-red text-white',
      variant === 'secondary' && 'bg-brutal-cream text-brutal-black',
      variant === 'ghost' && 'bg-transparent border-transparent shadow-none',
      // Sizes
      size === 'sm' && 'px-3 py-1.5 text-sm',
      size === 'md' && 'px-4 py-2 text-base',
      size === 'lg' && 'px-6 py-3 text-lg',
    )}>
      {children}
    </button>
  );
}
```

**Key principle**: Components use semantic token names, not hardcoded values.

## Core Mission

Generate component templates that:
1. Use design tokens correctly (semantic names, not hex values)
2. Include common variants (size, color, state)
3. Have accessibility built in (ARIA, keyboard, focus)
4. Are framework-idiomatic (React hooks, Vue composition, Svelte stores)

## When to Use

✅ Use when:
- Starting a component library with generated tokens
- Need consistent token usage across components
- Want accessibility baked into templates
- Bootstrapping a design system implementation

❌ Do NOT use when:
- Need tokens only (use design-system-generator)
- Need complete UI library (use shadcn/ui or similar)
- Customizing existing components (just edit them)

## Component Catalog

### Core Components

| Component | Variants | Accessibility |
|-----------|----------|---------------|
| Button | primary, secondary, ghost, destructive | ✅ Focus ring, disabled state |
| Input | default, error, disabled | ✅ Label association, error announcement |
| Card | default, interactive, highlighted | ✅ Semantic article/section |
| Badge | default, success, warning, error | ✅ Status announcements |

### Layout Components

| Component | Variants | Features |
|-----------|----------|----------|
| Container | default, narrow, wide | Max-width + padding |
| Stack | vertical, horizontal | Gap using spacing tokens |
| Grid | 2-col, 3-col, 4-col, auto | Responsive breakpoints |

### Interactive Components

| Component | Variants | Accessibility |
|-----------|----------|---------------|
| Dialog | default, alert | ✅ Focus trap, escape close |
| Dropdown | default | ✅ Keyboard navigation |
| Tabs | default | ✅ Arrow key navigation |
| Toggle | default | ✅ Switch role |

## Template Structure

Each component template includes:

```typescript
// 1. Type definitions
interface ComponentProps {
  variant?: 'primary' | 'secondary';
  size?: 'sm' | 'md' | 'lg';
  // ... other props
}

// 2. Component implementation
export function Component({ variant, size, ...props }: ComponentProps) {
  // Token-based styling
  // Accessibility attributes
  // Event handlers
}

// 3. Subcomponents (if applicable)
Component.Header = function Header() { /* ... */ };
Component.Body = function Body() { /* ... */ };

// 4. Default export
export default Component;
```

## Framework Templates

### React + Tailwind

```tsx
// Uses: className, cn() utility, React.forwardRef for refs
import { forwardRef } from 'react';
import { cn } from '@/lib/utils';

interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
  variant?: 'primary' | 'secondary';
}

export const Button = forwardRef<HTMLButtonElement, ButtonProps>(
  ({ variant = 'primary', className, ...props }, ref) => (
    <button
      ref={ref}
      className={cn(
        'border-3 border-brutal-black shadow-brutal',
        variant === 'primary' && 'bg-brutal-red',
        className
      )}
      {...props}
    />
  )
);
```

### React + CSS Variables

```tsx
// Uses: style prop with CSS variables, CSS modules
import styles from './Button.module.css';

export function Button({ variant = 'primary', ...props }) {
  return (
    <button
      className={`${styles.button} ${styles[variant]}`}
      style={{
        '--button-shadow': 'var(--shadow-md)',
        '--button-border': 'var(--border-width) solid var(--color-border)',
      }}
      {...props}
    />
  );
}
```

### Vue 3 + Composition API

```vue
<script setup lang="ts">
interface Props {
  variant?: 'primary' | 'secondary';
  size?: 'sm' | 'md' | 'lg';
}

const props = withDefaults(defineProps<Props>(), {
  variant: 'primary',
  size: 'md',
});

const classes = computed(() => [
  'border-3 border-brutal-black shadow-brutal',
  props.variant === 'primary' && 'bg-brutal-red',
  props.variant === 'secondary' && 'bg-brutal-cream',
]);
</script>

<template>
  <button :class="classes">
    <slot />
  </button>
</template>
```

### Svelte

```svelte
<script lang="ts">
  export let variant: 'primary' | 'secondary' = 'primary';
  export let size: 'sm' | 'md' | 'lg' = 'md';
</script>

<button
  class="border-3 border-brutal-black shadow-brutal"
  class:bg-brutal-red={variant === 'primary'}
  class:bg-brutal-cream={variant === 'secondary'}
  on:click
>
  <slot />
</button>
```

## Accessibility Patterns

### Focus Management

```tsx
// All interactive components include visible focus
'focus:outline-none focus-visible:ring-2 focus-visible:ring-offset-2'
'focus-visible:ring-brutal-blue'
```

### Keyboard Navigation

```tsx
// Dropdown with keyboard support
function handleKeyDown(e: KeyboardEvent) {
  switch (e.key) {
    case 'ArrowDown': focusNext(); break;
    case 'ArrowUp': focusPrev(); break;
    case 'Escape': close(); break;
    case 'Enter': select(); break;
  }
}
```

### ARIA Attributes

```tsx
// Dialog with proper ARIA
<div
  role="dialog"
  aria-modal="true"
  aria-labelledby="dialog-title"
  aria-describedby="dialog-description"
>
```

## Trend-Specific Patterns

### Neobrutalism Components

```tsx
// Hard shadows, bold borders, transform on interaction
'border-3 border-black shadow-brutal'
'hover:shadow-brutal-hover hover:-translate-x-0.5 hover:-translate-y-0.5'
'active:shadow-brutal-active active:translate-x-0.5 active:translate-y-0.5'
```

### Glassmorphism Components

```tsx
// Frosted glass, subtle borders, backdrop blur
'bg-glass-white/10 backdrop-blur-glass'
'border border-glass-white/20'
'shadow-glass'
```

### Terminal Components

```tsx
// Monospace, green-on-black, CRT effects
'font-mono bg-term-bg text-term-green'
'border border-term-green/30'
'shadow-term-glow'
```

## Generation Workflow

```
1. design-system-generator → tokens (Tailwind/CSS)
2. component-template-generator → component code
3. Customize variants and props as needed
4. design-system-documenter → component docs
```

## See Also

### References
- `references/component-patterns.md` - Full patterns for neobrutalism, glassmorphism, terminal, web3, swiss
- `references/component-catalog.md` - **NEW**: 21st.dev component counts (1400+ components)
  - Marketing blocks: 73 heroes, 34 CTAs, 11 nav menus, 36 features
  - UI components: 130 buttons, 102 inputs, 79 cards, 40 accordions
  - Design system references: Elastic UI, HeroUI, Ariakit, shadcn

### Related Skills
- design-system-generator - Generate tokens first (24 trends, 31 styles)
- design-system-documenter - Document generated components

© curiositech · MIT · curiositech/some_claude_skills

Similar skills

All skills for Frontend and UI →

From the same set180

The whole set →
anthropic-technical-deep-dive anthropic-technical-deep-dive builds deep technical preparation for Anthropic interviews: Constitutional AI, RLHF, interpretability, scaling laws, MCP, agentic systems, and AI safety. CX Codex +1 141installs human-gate-designer human-gate-designer designs human-in-the-loop review points for DAG workflows: what to show a person, how to collect feedback, and how to route it back. Fits when you add approval gates to agent pipelines. CX Codex +1 141installs error-handling-patterns The error-handling-patterns skill for Claude Code designs error handling in TypeScript and Python, supporting the choice between exceptions and Result types and the design of recovery flows. CX Codex +1 140installs dependency-management dependency-management guides agents through evaluating third-party packages, locking strict versions, and setting up security audits with Dependabot or Renovate. CX Codex +1 140installs recursive-synthesis recursive-synthesis runs a document through six phases, from ten parallel agent positions to a merged final text. Built for constitutions, charters and architecture decisions. CX Codex +1 138installs ultimate-seo-geo-skill ultimate-seo-geo-skill audits a site across 21 SEO modules, scores its health from 0 to 100, then turns the findings into a fix plan and deployable markup. CX Codex +1 121installs 2026-legal-research-agent 2026-legal-research-agent is a Claude Code skill that finds and collects expungement law data state by state across the US. It configures Firecrawl jobs and validates results. CX Codex +1 2installs orchestrator orchestrator breaks complex requests into subtasks, delegates them to specialist skills, and combines their work. It can also create a skill when a needed capability is missing. CX Codex +1 2installs

Project sponsors

Companies that keep this analytics open