Frontend UI Design

Frontend Ui Design

When to Use

Trigger phrases:

• "frontend ui design"

• "Design and build production-grade UI components using React, Vue, or vanilla HTM"

• When building UI components or pages from scratch

• When creating a design system or component library

• When implementing responsive layouts

• When improving accessibility of existing UI

When NOT to Use

• For backend logic (use backend skills)
• For database design (use data skills)
• For mobile-native apps (use mobile development skills)

Overview

Production-grade frontend UI design bridges visual design and engineering, transforming wireframes into accessible, responsive, and performant interfaces. This skill covers the full lifecycle — from component architecture and design tokens through CSS implementation, accessibility auditing, and design system distribution.

Modern frontend development spans two dominant ecosystems: React (with its component composition model and hook-based state management) and Vue (with its progressive framework and reactive system), alongside vanilla HTML/CSS for lightweight projects. Each requires mastery of component hierarchy, state management patterns, responsive layout strategies, and cross-browser compatibility testing.

Key capabilities include implementing design tokens via CSS custom properties or Tailwind configuration, building accessible components that meet WCAG 2.1 AA standards, creating responsive layouts using CSS Grid and Flexbox, and packaging reusable component libraries for multi-project reuse. CSS architecture choices — Tailwind utility classes, CSS Modules for scoped styles, or CSS-in-JS libraries — each trade locality against bundle size and runtime overhead.

The goal is consistent, keyboard-navigable, performant UIs that work reliably across devices from 320px mobile screens to 4K desktop displays, while remaining maintainable as the codebase grows.

Workflow

1. Define requirements — Collect user stories, wireframes, brand guidelines, and target breakpoints. Document component hierarchy with a tree diagram before writing code.
2. Select architecture — Choose atomic design for component decomposition, state management approach (React Context, Zustand, Pinia for Vue), and CSS strategy (Tailwind, CSS Modules, styled-components).
3. Build design tokens — Define color palette, typography scale, spacing units, and shadows as CSS custom properties or Tailwind config. Verify contrast ratios meet WCAG AA.
4. Implement component hierarchy — Build atoms (Button, Input) then molecules (FormField, Card) then organisms (DataTable, Navigation). Prefer composition over inheritance.
5. Apply responsive styling — Use CSS Grid for page-level layouts and Flexbox for component-level alignment. Implement mobile-first breakpoints with consistent naming (sm, md, lg, xl).
6. Integrate accessibility — Add semantic HTML, ARIA attributes, keyboard event handlers, and focus management. Test with screen readers and colour contrast analysers.
7. Test and iterate — Run visual regression tests (Storybook, Chromatic), cross-browser checks, and performance audits (Lighthouse). Collect feedback and refine.

Anti-Rationalization Table

Code Example (React)

interface ButtonProps {
  variant: 'primary' | 'secondary' | 'danger';
  size: 'sm' | 'md' | 'lg';
  children: React.ReactNode;
  onClick?: () => void;
  disabled?: boolean;
}

export function Button({ variant, size, children, onClick, disabled }: ButtonProps) {
  return (
    <button
      className={`btn btn-${variant} btn-${size}`}
     
      disabled={disabled}
      aria-disabled={disabled}
    >
      {children}
    </button>
  );
}

Code Example (CSS Responsive Grid)

/* Responsive card grid with auto-fit columns */
.card-grid {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
  gap: clamp(1rem, 2vw, 2rem);
  padding: var(--spacing-lg);
}

.card {
  border-radius: 0.5rem;
  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
  transition: box-shadow 0.2s ease;
}

@media (prefers-reduced-motion: reduce) {
  .card {
    transition: none;
  }
}

Setup & Configuration

# Create React + TypeScript project with Vite
npm create vite@latest my-app -- --template react-ts
cd my-app

# Install Tailwind CSS v4 with Vite plugin
npm install tailwindcss @tailwindcss/vite

# Install Storybook for component workbench
npx storybook@latest init

# Chromatic for visual regression in CI
npm install -D chromatic

For Vue projects:

npm create vue@latest my-vue-app
cd my-vue-app
npm install unocss

Process

1. Prepare — Gather brand assets, wireframes, and content strategy. Set up toolchain (Vite, Tailwind, Storybook).
2. Design tokens — Establish color palette, typography scale, spacing units, and shadows as CSS custom properties or Tailwind config.
3. Component build — Layer components via atomic design (atoms -> molecules -> organisms). Implement responsive variants and dark mode.
4. Quality check — Run Lighthouse, AXE DevTools, keyboard navigation audit, and cross-browser visual diff.
5. Deliver and document — Export component library with usage documentation, Storybook preview, and live demo URL.

Verification

• All components render correctly at breakpoints: 320px, 768px, 1024px, 1440px
• Color contrast passes WCAG 2.1 AA minimum (4.5:1 for normal text, 3:1 for large)
• Keyboard navigation covers Tab order, visible focus indicators, Enter/Space activation, Escape close
• Screen reader announces dynamic content changes via ARIA live regions
• CSS architecture has no !important overrides or specificity battles
• Design tokens defined in a single source of truth (CSS custom properties or Tailwind config)
• Components maintain consistent spacing using the established scale (4px/8px base)
• Lighthouse performance score >= 90 for the rendered page

Common Issues & Troubleshooting

Monetization