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.zipInstalls 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.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
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
- Read the UI kit. List available components: `ls packages/ui/src/components/` (or equivalent path). Note what exists.
- 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.
- 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:
- Create it in the UI kit package
- Follow existing component patterns (props interface, naming, file structure)
- Use only design tokens for all visual values
- Export it from the UI kit barrel file
- 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.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| design (this skill) | 0 | 4mo | No flags | Beginner |
| ui-styling | 12 | 9mo | Review | Beginner |
| tailwind-design-system | 34 | 2mo | No flags | Intermediate |
| figma | 22 | 4mo | No flags | Intermediate |
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.
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.
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.
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.
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.
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.