home / skills / phrazzld / claude-config / design-theme

design-theme skill

/skills/design-theme

This skill implements a CSS-first design theme using tokens, delegating work to Kimi and validating with Claude across components.

npx playbooks add skill phrazzld/claude-config --skill design-theme

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.1 KB
---
name: design-theme
description: |
  DESIGN-THEME
---

---
description: Create or update theme with design tokens
argument-hint: "[selected-direction]"
---

# DESIGN-THEME

Implement a theme system with proper design tokens.

## MANDATORY: Kimi Delegation

**Theme implementation MUST be delegated to Kimi K2.5 via MCP.**

Kimi excels at CSS/Tailwind work:

```javascript
mcp__kimi__spawn_agent({
  prompt: `Implement design theme with tokens:
Direction: ${selectedDNA}
Typography: ${fontStack}
Colors: ${palette}
Use Tailwind 4 @theme directive (CSS-first).
OKLCH for colors. Modular type scale.
Output: Update app/globals.css with token architecture.
Then update components to use tokens.`,
  thinking: true
})
```

**Workflow:**
1. Define direction → Claude (from catalog selection)
2. Implement tokens → Kimi (CSS/Tailwind work)
3. Validate → Claude (quality checks)

## When to Use

- After `/design-catalog` — user selected a direction
- After `/design-audit` — fixing design debt
- Starting fresh — establishing design system

## Process

### 1. Understand Direction

If `$1` provided (from catalog selection):
- Load the selected design DNA
- Extract: typography, colors, spacing, motion

If from audit:
- Address issues found
- Maintain existing patterns where working

### 2. Define Token Architecture

Using Tailwind 4 `@theme` directive (CSS-first):

```css
@theme {
  /* Colors - OKLCH for perceptual uniformity */
  --color-primary: oklch(0.7 0.15 250);
  --color-primary-hover: oklch(0.65 0.15 250);

  /* Typography - modular scale */
  --font-sans: "Custom Font", system-ui, sans-serif;
  --text-xs: 0.75rem;
  --text-sm: 0.875rem;
  --text-base: 1rem;
  --text-lg: 1.125rem;
  --text-xl: 1.25rem;

  /* Spacing - consistent scale */
  --spacing-1: 0.25rem;
  --spacing-2: 0.5rem;
  --spacing-4: 1rem;
  --spacing-8: 2rem;

  /* Shadows */
  --shadow-sm: 0 1px 2px oklch(0 0 0 / 0.05);
  --shadow-md: 0 4px 6px oklch(0 0 0 / 0.1);

  /* Radii */
  --radius-sm: 0.25rem;
  --radius-md: 0.5rem;
  --radius-lg: 1rem;
}
```

### 3. Implement Tokens

Update `app/globals.css` (or equivalent):
- Define all tokens in `@theme`
- Remove `tailwind.config.ts` (CSS-first approach)
- Migrate hardcoded values to tokens

### 4. Update Components

For each component:
- Replace hardcoded colors → `var(--color-*)`
- Replace magic numbers → `var(--spacing-*)`
- Ensure dark mode support

### 5. Validate

Run quality checks:
```
/check-quality  # Typecheck, lint, tests
/rams           # Accessibility score
```

### 6. Document Theme

Create or update design system docs:

```markdown
## Theme: [Name]

### Colors
[Visual color palette with names and values]

### Typography
[Font stack, scale, usage guidelines]

### Spacing
[Scale and when to use each]

### Components
[Key component patterns]
```

## Token Naming Convention

```
--category-variant-state

Examples:
--color-primary
--color-primary-hover
--color-text-muted
--text-heading-1
--spacing-component-gap
```

## Output

Theme implemented with tokens. Commit:
```bash
git add -A && git commit -m "feat: implement design system tokens"
```

Overview

This skill implements a CSS-first design theme using explicit design tokens. It defines a consistent token architecture (colors in OKLCH, modular typography, spacing, shadows, radii) and upgrades components to consume those tokens. Theme implementation is delegated to Kimi K2.5 via MCP while quality checks and direction selection are coordinated with Claude.

How this skill works

The skill takes a selected design direction (DNA) or audit findings and extracts typography, color palette, spacing, and motion. It generates a token set inside a Tailwind 4 @theme block in app/globals.css, migrates hardcoded values into tokens, and updates components to reference var(--*) tokens. Implementation is delegated to Kimi via an MCP spawn call; Claude performs direction selection and final validation.

When to use it

  • After a design direction is chosen from /design-catalog
  • When addressing design debt found by /design-audit
  • When starting a new product or major redesign to establish a system
  • When migrating from config-first Tailwind to CSS-first token architecture

Best practices

  • Always derive colors in OKLCH for perceptual uniformity and provide hover/active states
  • Use a modular type scale and name text tokens semantically (e.g., --text-base, --text-heading-1)
  • Keep spacing on a consistent scale and replace magic numbers with spacing tokens
  • Prefer CSS-first @theme block; remove tailwind config overrides to avoid duplication
  • Ensure dark mode tokens and component variants are included before wide rollout

Example use cases

  • Create a new theme after a catalog selection: extract DNA, define tokens, implement CSS
  • Fix inconsistent button styles discovered during a design audit by migrating colors and spacing to tokens
  • Standardize typography across the app by replacing inline font sizes with a modular token scale
  • Introduce dark mode by adding inverted token sets and updating components to use semantic tokens

FAQ

How is implementation delegated to Kimi?

The skill spawns Kimi K2.5 via MCP with a prompt that includes the selected DNA, font stack, palette, and required output: update app/globals.css with the @theme token architecture and update components to use tokens.

What files are updated?

Primary output is app/globals.css containing the @theme tokens; components are updated to reference var(--*) tokens. The workflow removes redundant Tailwind config in favor of CSS-first tokens.