home / skills / htooayelwinict / claude-config / ui-ux-design

ui-ux-design skill

/skills/ui-ux-design

This skill helps ui-ux designers audit and implement accessible, responsive UI patterns using shadcn/ui components and Tailwind tokens.

npx playbooks add skill htooayelwinict/claude-config --skill ui-ux-design

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

Files (2)
SKILL.md
3.2 KB
---
name: ui-ux-design
description: Design and implement UI/UX changes using existing components and Tailwind tokens; ensure accessibility. EXCLUSIVE to ui-ux-designer agent.
allowed-tools: Read, Edit, Grep, Glob, Write, mcp_context7, mcp_playwright, mcp_zai-mcp-server
---
# UI/UX Design

**Exclusive to:** `ui-ux-designer` agent

## 📚 Context7 (Memory) — Up-to-Date Docs

Lookup latest component patterns and accessibility guidelines:
```
mcp_context7_resolve-library-id(libraryName="shadcn-ui", query="dialog modal")
mcp_context7_query-docs(libraryId="/shadcn-ui/ui", query="accessible form patterns")
```

## 🖼️ Visual Verification (Web Apps)

After UI implementation, capture and analyze:

### Screenshot & Analyze
```
mcp_playwright_browser_navigate(url="http://localhost:8000/[page]")
mcp_playwright_browser_take_screenshot(filename="ui-check.png")

mcp_zai-mcp-server_analyze_image(
  image_path="ui-check.png",
  prompt="Check this UI for: design consistency, spacing, alignment, accessibility"
)
```

### Responsive Verification
```
mcp_playwright_browser_resize(width=375, height=812)   # Mobile
mcp_playwright_browser_resize(width=768, height=1024)  # Tablet  
mcp_playwright_browser_resize(width=1920, height=1080) # Desktop
```

## Instructions

1. Audit existing UI for patterns to follow
2. Use existing shadcn/ui components (see component map below)
3. Follow Tailwind design tokens, avoid custom CSS
4. Ensure accessibility (keyboard, labels, contrast)
5. Test responsive behavior (mobile + desktop)

## shadcn/ui Component Map

| Need | Component |
|------|-----------|
| Button | `<Button>` |
| Input | `<Input>` |
| Select | `<Select>` |
| Modal | `<Dialog>` |
| Dropdown | `<DropdownMenu>` |
| Toast | `<Toast>` |
| Card | `<Card>` |
| Alert | `<Alert>` |

## Design Tokens

### Colors
```tsx
text-foreground           // Primary text
text-muted-foreground     // Secondary text
bg-background             // Page background
bg-muted                  // Subtle background
border-border             // Default borders
```

### Spacing
```tsx
p-1 (4px)  p-2 (8px)  p-4 (16px)  p-6 (24px)  p-8 (32px)
```

## Responsive Breakpoints
| Prefix | Width | Device |
|--------|-------|--------|
| `sm:` | 640px | Phone |
| `md:` | 768px | Tablet |
| `lg:` | 1024px | Laptop |
| `xl:` | 1280px | Desktop |

## Accessibility Checklist (WCAG 2.1)

### Forms
- [ ] Inputs have `<Label>` with `htmlFor`
- [ ] Errors linked with `aria-describedby`
- [ ] Invalid state with `aria-invalid`

### Interactive
- [ ] Keyboard accessible
- [ ] Focus states visible
- [ ] Logical focus order

### Content
- [ ] Images have `alt` text
- [ ] 4.5:1 color contrast

## Form Pattern
```tsx
<Label htmlFor="name">Name</Label>
<Input
    id="name"
    aria-invalid={!!errors.name}
    aria-describedby={errors.name ? 'name-error' : undefined}
/>
{errors.name && (
    <p id="name-error" className="text-sm text-destructive">
        {errors.name}
    </p>
)}
```

## Rules
- âś… Use existing components and tokens
- âś… Follow `docs/code-standards.md`
- âś… Implement loading/error states
- ❌ Don't create new colors/fonts
- ❌ Don't use inline styles
- ❌ Don't skip mobile responsiveness

## Examples
- "Improve a form's validation UX"
- "Adjust layout for readability"

Overview

This skill designs and implements UI/UX changes using existing shadcn/ui components and Tailwind design tokens while ensuring accessibility and responsive behavior. It is exclusive to the ui-ux-designer agent and focuses on delivering consistent, accessible interfaces without adding new colors or custom CSS. The skill emphasizes verification through visual checks and responsive testing.

How this skill works

I audit the current UI for established patterns and map changes to the component set (Button, Input, Dialog, etc.). Implementations use Tailwind tokens (text-foreground, bg-background, border-border, spacing utilities) and existing components to avoid custom styles. After implementation I capture screenshots at multiple breakpoints and run automated visual/accessibility analyses to confirm spacing, alignment, keyboard behavior, and contrast.

When to use it

  • Improve or standardize forms and validation UX across the app
  • Refactor layouts to match design tokens and component patterns
  • Add or update interactive components (modals, dropdowns, toasts) using existing components
  • Verify responsive behavior for mobile, tablet, and desktop before release
  • Fix accessibility issues: focus order, labels, contrast, and keyboard support

Best practices

  • Always reuse the mapped shadcn/ui component for the UI need (e.g., <Input>, <Dialog>)
  • Use only Tailwind design tokens for colors, spacing, and typography—no new tokens or inline styles
  • Include accessible form patterns: Label with htmlFor, aria-describedby for errors, aria-invalid for invalid fields
  • Test keyboard interactions and visible focus states; confirm logical focus order
  • Capture screenshots at mobile, tablet, and desktop widths and run visual analysis for consistency

Example use cases

  • Improve form validation: attach error messages with aria-describedby and visible border/error states
  • Convert a custom modal to <Dialog> and ensure focus trapping and keyboard dismissal
  • Standardize buttons and spacing across a settings page using design tokens
  • Adjust a card grid to maintain readable spacing across sm/md/lg breakpoints
  • Validate image alt text, color contrast, and focus styles after a redesign

FAQ

Can I add new colors or custom fonts for a redesign?

No. Follow the rule set: use existing Tailwind design tokens and avoid adding new colors or fonts.

How do you verify accessibility after changes?

I run a checklist (labels, aria attributes, focus order, contrast) and capture screenshots at multiple breakpoints to analyze spacing, alignment, and accessibility programmatically.