Standardizes UI component and layout work by enforcing design token and component usage.

Install

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

Installs to .claude/skills/design-apakou

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.

TRIGGER: When creating or modifying UI components, pages, or layouts. Any work in component files, page files, or style files.
126 chars · catalog description✓ has a “when” trigger
Beginner

Key capabilities

  • Enforce use of existing UI kit components
  • Apply design tokens for visual values
  • Compose pages using UI kit components
  • Identify and create missing UI kit components
  • Scan code for hardcoded visual values
  • Scan code for arbitrary Tailwind values

How it works

The skill guides UI development to use existing components and design tokens, preventing hardcoded values and promoting composition over custom styling, and includes verification steps to check for violations.

Inputs & outputs

You give it
UI component, page, or layout modification request
You get back
UI code adhering to design system rules, or a new UI kit component

When to use design

  • Updating UI components
  • Applying design tokens
  • Standardizing page layouts

About this skill

Design System

TRIGGER: When creating or modifying UI components, pages, or layouts. Any work in component files, page files, or style files.

Enforce the project's design system. All UI work uses existing components and tokens. No hardcoded values. No one-off styles.

Rules

Use components from the UI kit package. Before creating any new component, check what exists in the UI kit (`packages/ui/` or equivalent). If a component exists that does what you need, use it. If it needs a variant, extend it in the UI kit do not create a one-off version in the app.

Never hardcode visual values. This applies to:

  • Colors → use design tokens (`var(--color-primary)`, `text-primary`, etc.)
  • Spacing → use the spacing scale (`gap-4`, `p-6`, etc.)
  • Font sizes → use the type scale (`text-sm`, `text-lg`, etc.)
  • Font weights → use the weight tokens (`font-medium`, `font-semibold`, etc.)
  • Border radius → use the radius tokens (`rounded-md`, `rounded-lg`, etc.)
  • Shadows → use the shadow tokens (`shadow-sm`, `shadow-md`, etc.)
  • Breakpoints → use the defined breakpoints, never arbitrary pixel values

If you write a hex code, rgb value, pixel value for spacing, or arbitrary Tailwind value (`text-[14px]`, `bg-[#3B82F6]`, `p-[13px]`), you are violating this skill.

Compose, don't create. Build pages by composing UI kit components. A page should be mostly layout and composition with very little custom styling. If a page requires significant custom CSS, that's a signal that the UI kit is missing a component create it in the UI kit, not in the page.

Before Writing UI Code

  1. Read the UI kit. List available components: `ls packages/ui/src/components/` (or equivalent path). Note what exists.
  2. Read the design tokens. Find the token/theme file (e.g., `tailwind.config.ts`, `globals.css`, `theme.ts`) and note available colors, spacing, typography, and other tokens.
  3. Plan the composition. For each section of the UI, identify which existing components to use. Flag any gaps where a new UI kit component is needed.

When a Component Doesn't Exist

Do not build it inline in the page. Instead:

  1. Create it in the UI kit package
  2. Follow existing component patterns (props interface, naming, file structure)
  3. Use only design tokens for all visual values
  4. Export it from the UI kit barrel file
  5. Import and use it in the page

Verification

After writing UI code, scan for violations:

```bash

Hardcoded colors

grep -rn '#[0-9a-fA-F]{3,8}|rgb(|rgba(|hsl(' $CHANGED_TSX_FILES 2>/dev/null

Arbitrary Tailwind values (square bracket syntax)

grep -rn '[\d+px]|[#.+]|[\d+rem]' $CHANGED_TSX_FILES 2>/dev/null

Inline styles

grep -rn 'style={{' $CHANGED_TSX_FILES 2>/dev/null ```

Every hit is a violation. Replace with the appropriate design token or UI kit component.

When not to use it

  • When creating one-off styles for a specific page
  • When hardcoding hex codes, RGB values, or pixel values for spacing
  • When writing inline styles in UI code

Limitations

  • Requires an existing UI kit package and design tokens
  • Prohibits hardcoding of visual values
  • New components must be created within the UI kit, not inline in pages

How it compares

This approach mandates the use of a predefined design system and tokens, ensuring consistency and maintainability across the UI, unlike ad-hoc styling or component creation.

Compared to similar skills

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

SkillInstallsUpdatedSafetyDifficulty
design (this skill)04moNo flagsBeginner
ui-styling129moReviewBeginner
tailwind-design-system342moNo flagsIntermediate
figma224moNo flagsIntermediate

Try saying

Example prompts that trigger this skill in your AI assistant.

You might also like

ui-styling

mrgoonie

Create beautiful, accessible user interfaces with shadcn/ui components (built on Radix UI + Tailwind), Tailwind CSS utility-first styling, and canvas-based visual designs. Use when building user interfaces, implementing design systems, creating responsive layouts, adding accessible components (dialogs, dropdowns, forms, tables), customizing themes and colors, implementing dark mode, generating visual designs and posters, or establishing consistent styling patterns across applications.

12132

tailwind-design-system

wshobson

Build scalable design systems with Tailwind CSS, design tokens, component libraries, and responsive patterns. Use when creating component libraries, implementing design systems, or standardizing UI patterns.

3495

figma

openai

Use the Figma MCP server to fetch design context, screenshots, variables, and assets from Figma, and to translate Figma nodes into production code. Trigger when a task involves Figma URLs, node IDs, design-to-code implementation, or Figma MCP setup and troubleshooting.

2266

design-system-patterns

wshobson

Build scalable design systems with design tokens, theming infrastructure, and component architecture patterns. Use when creating design tokens, implementing theme switching, building component libraries, or establishing design system foundations.

1157

interaction-design

wshobson

Design and implement microinteractions, motion design, transitions, and user feedback patterns. Use when adding polish to UI interactions, implementing loading states, or creating delightful user experiences.

1550

web-design-reviewer

github

This skill enables visual inspection of websites running locally or remotely to identify and fix design issues. Triggers on requests like "review website design", "check the UI", "fix the layout", "find design problems". Detects issues with responsive design, accessibility, visual consistency, and layout breakage, then performs fixes at the source code level.

750

Search skills

Search the agent skills registry