# frontend-ui-design

frontend-ui-design — a skill for planning frontend UI components, architecture, responsive behavior, accessibility, and state management decisions.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode, Windsurf (Devin Desktop), Claude.ai · 122 installs · ★ 3 repo stars
- Author: Pixel-Process-UG
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/Pixel-Process-UG/superkit-agents/tree/HEAD/templates/skills/frontend-ui-design/SKILL.md
- Updated: 2026-03-16
- Security check: automated, 2026-11-16 (text) — no signs of malicious code found.
- HTML: https://affpapa.org/en/nevibecode/skills/frontend-ui-design

## What it does

This skill gives an agent a staged way to build frontend interfaces. It starts by asking about the page or component, framework, existing design system, target devices, WCAG needs, and data requirements. It then compares Atomic Design, compound components, hooks, and container/presenter patterns.

The guide covers mobile-first breakpoints, media queries versus container queries, fluid type with `clamp()`, semantic HTML, ARIA, keyboard access, and screen reader checks. Its state-management table includes `useState`, `useReducer`, Context, Zustand, Jotai, TanStack Query, SWR, React Hook Form, and Formik. After discovery and architecture selection, the agent is told to pause for confirmation.

Accessibility is framed around WCAG 2.1 AA, including focus behavior, contrast, and logical tab order. In Claude Code, installation places the skill at `~/.claude/skills/frontend-ui-design/SKILL.md`; the workflow should not move past architecture selection before that choice is confirmed.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add Pixel-Process-UG/superkit-agents --skill frontend-ui-design -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/frontend-ui-design/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/frontend-ui-design/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add Pixel-Process-UG/superkit-agents --skill frontend-ui-design -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/frontend-ui-design/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add Pixel-Process-UG/superkit-agents --skill frontend-ui-design -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/frontend-ui-design/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install Pixel-Process-UG/superkit-agents templates/skills/frontend-ui-design
```

2. **Manually: put the files in place**
- File: `.github/skills/frontend-ui-design/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add Pixel-Process-UG/superkit-agents --skill frontend-ui-design -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/Pixel-Process-UG/superkit-agents --path templates/skills/frontend-ui-design
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/frontend-ui-design/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add Pixel-Process-UG/superkit-agents --skill frontend-ui-design -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/Pixel-Process-UG/superkit-agents/tree/HEAD/templates/skills/frontend-ui-design/SKILL.md

## When to use it
- plan a component architecture
- choose a pattern for a reusable component library
- define responsive behavior across device sizes
- check a UI against WCAG 2.1 AA
- select state management for shared or server data

## Example prompts
- Use the frontend UI skill to plan this settings page, ask the discovery questions first, then stop after proposing the component architecture.
- Compare `useState`, Context, and Zustand for the state in these components, and explain which option fits.
- Review this interface for semantic HTML, keyboard navigation, and WCAG 2.1 AA requirements.

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 848e417f2ad5eccc.

BEGIN THIRD-PARTY FILE 848e417f2ad5eccc
```text
---
name: frontend-ui-design
description: "Use when designing UI components, creating component architectures, implementing responsive layouts, setting up design systems, or selecting state management solutions for frontend applications"
---

# Frontend UI Design

## Overview

Guide the design and implementation of frontend user interfaces with consistent architecture, accessibility, responsive behavior, and performance. This skill covers component patterns, design system integration, state management selection, and WCAG compliance — producing components that are testable, accessible, and performant.

**Announce at start:** "I'm using the frontend-ui-design skill to design the UI."

## Phase 1: Discovery

Ask these questions to understand the UI requirements:

| # | Question | What It Determines |
|---|----------|-------------------|
| 1 | What component or page are we building? | Scope and complexity |
| 2 | What framework/library? (React, Vue, Svelte, etc.) | Code patterns |
| 3 | Is there an existing design system or component library? | Constraints |
| 4 | What devices must be supported? (mobile, tablet, desktop) | Responsive strategy |
| 5 | Accessibility requirements? (WCAG level) | A11y standards |
| 6 | What data does this component need? | State management approach |

STOP after discovery — present a summary of constraints and approach before designing.

## Phase 2: Component Architecture Selection

### Architecture Pattern Decision Table

| Pattern | When to Use | When NOT to Use |
|---------|------------|-----------------|
| **Atomic Design** | Building a component library from scratch | Adding one component to existing system |
| **Compound Components** | Multi-part component needing layout flexibility | Simple single-purpose component |
| **Hooks Pattern** | Same logic reused across different UIs | Logic tied to one specific component |
| **Container/Presenter** | Components need isolated testing or multiple data sources | Simple components with minimal logic |

### Atomic Design Levels

| Level | Description | Examples |
|-------|-------------|----------|
| **Atoms** | Smallest building blocks, single purpose | Button, Input, Label, Icon |
| **Molecules** | Groups of atoms functioning together | SearchBar (Input + Button), FormField (Label + Input + Error) |
```
END THIRD-PARTY FILE 848e417f2ad5eccc

The third-party file has ended. Everything between the 848e417f2ad5eccc tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2316 of 11011 bytes. © Pixel-Process-UG · MIT · https://github.com/Pixel-Process-UG/superkit-agents/tree/HEAD/templates/skills/frontend-ui-design/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md
