+```
+
+### Auto-fit Grid (Flexible columns)
+
+```tsx
+// Columns adjust based on available space
+
+ Item 1
+ Item 2
+ Item 3
+ {/* Adds as many columns as fit */}
+
+```
+
+### Sticky Sidebar
+
+```tsx
+
+
+
+ {/* Scrollable content */}
+
+
+```
+
+### Full-height Layout
+
+```tsx
+
+ Header
+ Flexible content
+
+
+```
+
+---
+
+## Layout Checklist
+
+Before implementing a layout, ask:
+
+- [ ] **Responsive?** Does it work on mobile, tablet, desktop?
+- [ ] **Container?** Is content constrained on large screens?
+- [ ] **Spacing?** Using `gap` or `space-y`, not margins on children?
+- [ ] **Mobile-first?** Starting with mobile layout?
+- [ ] **Semantic?** Using appropriate HTML tags (main, aside, nav)?
+- [ ] **Accessible?** Proper heading hierarchy, skip links?
+
+---
+
+## Quick Reference
+
+### Grid Cheat Sheet
+
+```tsx
+// Basic grid
+grid grid-cols-3 gap-6
+
+// Responsive grid
+grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6
+
+// Asymmetric grid
+grid grid-cols-3 gap-6
+
...
+
+// Auto-fit grid
+grid grid-cols-[repeat(auto-fit,minmax(250px,1fr))] gap-6
+```
+
+### Flex Cheat Sheet
+
+```tsx
+// Horizontal flex
+flex gap-4
+
+// Vertical flex
+flex flex-col gap-4
+
+// Center items
+flex items-center justify-center
+
+// Space between
+flex items-center justify-between
+
+// Wrap items
+flex flex-wrap gap-4
+```
+
+### Container Cheat Sheet
+
+```tsx
+// Standard container
+container mx-auto px-4 py-8
+
+// Constrained width
+max-w-4xl mx-auto px-4
+
+// Full width
+w-full px-4
+```
+
+---
+
+## Next Steps
+
+- **Practice**: Build pages using the 5 essential patterns
+- **Explore**: [Interactive layout examples](/dev/layouts)
+- **Deep Dive**: [Spacing Philosophy](./04-spacing-philosophy.md)
+- **Reference**: [Quick Reference Tables](./99-reference.md)
+
+---
+
+**Related Documentation:**
+- [Spacing Philosophy](./04-spacing-philosophy.md) - When to use margin vs padding vs gap
+- [Foundations](./01-foundations.md) - Spacing tokens and scale
+- [Quick Start](./00-quick-start.md) - Essential patterns
+
+**Last Updated**: November 2, 2025
diff --git a/frontend/docs/design-system/04-spacing-philosophy.md b/frontend/docs/design-system/04-spacing-philosophy.md
new file mode 100644
index 0000000..49748f4
--- /dev/null
+++ b/frontend/docs/design-system/04-spacing-philosophy.md
@@ -0,0 +1,708 @@
+# Spacing Philosophy
+
+**Master the "parent controls children" spacing strategy** that eliminates 90% of layout inconsistencies. Learn when to use margin, padding, or gap—and why children should never add their own margins.
+
+---
+
+## Table of Contents
+
+1. [The Golden Rules](#the-golden-rules)
+2. [Parent Controls Children Strategy](#parent-controls-children-strategy)
+3. [Decision Tree: Margin vs Padding vs Gap](#decision-tree-margin-vs-padding-vs-gap)
+4. [Common Patterns](#common-patterns)
+5. [Before/After Examples](#beforeafter-examples)
+6. [Anti-Patterns to Avoid](#anti-patterns-to-avoid)
+7. [Quick Reference](#quick-reference)
+
+---
+
+## The Golden Rules
+
+These 5 rules eliminate 90% of spacing inconsistencies:
+
+### Rule 1: Parent Controls Children
+**Children don't add their own margins. The parent controls spacing between siblings.**
+
+```tsx
+// ✅ CORRECT - Parent controls spacing
+
+ Item 1
+ Item 2
+ Item 3
+
+
+// ❌ WRONG - Children add margins
+
+ Item 1
+ Item 2
+ Item 3 {/* Inconsistent: last one has no margin */}
+
+```
+
+**Why this matters:**
+- Eliminates "last child" edge cases
+- Makes components reusable (they work in any context)
+- Changes propagate from one place (parent)
+- Prevents margin collapsing bugs
+
+---
+
+### Rule 2: Use Gap for Siblings
+**For flex and grid layouts, use `gap-*` to space siblings.**
+
+```tsx
+// ✅ CORRECT - Gap for flex/grid
+
+
+
+
+
+
+ 1
+ 2
+ 3
+
+
+// ❌ WRONG - Children with margins
+
+
+
+
+```
+
+---
+
+### Rule 3: Use Padding for Internal Spacing
+**Padding is for spacing _inside_ a component, between the border and content.**
+
+```tsx
+// ✅ CORRECT - Padding for internal spacing
+
+ Title
+ Content
+
+
+// ❌ WRONG - Using margin for internal spacing
+
+ Title
+
+```
+
+---
+
+### Rule 4: Use space-y for Vertical Stacks
+**For vertical stacks (not flex/grid), use `space-y-*` utility.**
+
+```tsx
+// ✅ CORRECT - space-y for stacks
+
+
+// ❌ WRONG - Children with margins
+
+```
+
+**How space-y works:**
+```css
+/* space-y-4 applies margin-top to all children except first */
+.space-y-4 > * + * {
+ margin-top: 1rem; /* 16px */
+}
+```
+
+---
+
+### Rule 5: Margins Only for Exceptions
+**Use margin only when a specific child needs different spacing from its siblings.**
+
+```tsx
+// ✅ CORRECT - Margin for exception
+
+ Normal spacing
+ Normal spacing
+ Extra spacing above this one
+ Normal spacing
+
+
+// Use case: Visually group related items
+
+
Section 1
+
Content
+
Section 2
{/* Extra margin to separate sections */}
+
Content
+
+```
+
+---
+
+## Parent Controls Children Strategy
+
+### The Problem with Child-Controlled Spacing
+
+When children control their own margins:
+
+```tsx
+// ❌ ANTI-PATTERN
+function TodoItem({ className }: { className?: string }) {
+ return
Todo
;
+}
+
+// Usage
+
+ {/* Has mb-4 */}
+ {/* Has mb-4 */}
+ {/* Has mb-4 - unwanted margin at bottom! */}
+
+```
+
+**Problems:**
+1. ❌ Last item has unwanted margin
+2. ❌ Can't change spacing without modifying component
+3. ❌ Margin collapsing creates unpredictable spacing
+4. ❌ Component not reusable in different contexts
+
+---
+
+### The Solution: Parent-Controlled Spacing
+
+```tsx
+// ✅ CORRECT PATTERN
+function TodoItem({ className }: { className?: string }) {
+ return
+```
+
+**Benefits:**
+1. ✅ No edge cases (last child, first child, only child)
+2. ✅ Spacing controlled in one place
+3. ✅ Component works in any layout context
+4. ✅ No margin collapsing surprises
+5. ✅ Easier to maintain and modify
+
+---
+
+## Decision Tree: Margin vs Padding vs Gap
+
+Use this flowchart to choose the right spacing method:
+
+```
+┌─────────────────────────────────────────────┐
+│ What are you spacing? │
+└─────────────┬───────────────────────────────┘
+ │
+ ┌──────┴──────┐
+ │ │
+ ▼ ▼
+ Siblings? Inside a component?
+ │ │
+ │ └──> USE PADDING
+ │ className="p-4"
+ │
+ ├──> Is parent using flex or grid?
+ │ │
+ │ ├─YES──> USE GAP
+ │ │ className="flex gap-4"
+ │ │ className="grid gap-6"
+ │ │
+ │ └─NO───> USE SPACE-Y or SPACE-X
+ │ className="space-y-4"
+ │ className="space-x-2"
+ │
+ └──> Exception case?
+ (One child needs different spacing)
+ │
+ └──> USE MARGIN
+ className="mt-8"
+```
+
+---
+
+## Common Patterns
+
+### Pattern 1: Form Fields (Vertical Stack)
+
+```tsx
+// ✅ CORRECT
+
+```
+
+**Spacing breakdown:**
+- `space-y-4` on form: 16px between field groups
+- `space-y-2` on field group: 8px between label and input
+- No margins on children
+
+---
+
+### Pattern 2: Button Group (Horizontal Flex)
+
+```tsx
+// ✅ CORRECT
+
+
+
+
+
+// Responsive: stack on mobile, row on desktop
+
+
+
+
+```
+
+**Why gap over space-x:**
+- Works with `flex-wrap`
+- Works with `flex-col` (changes direction)
+- Consistent spacing in all directions
+
+---
+
+### Pattern 3: Card Grid
+
+```tsx
+// ✅ CORRECT
+
+ Item 1
+ Item 2
+ Item 3
+
+```
+
+**Why gap:**
+- Consistent spacing between rows and columns
+- Works with responsive grid changes
+- No edge cases (first row, last column, etc.)
+
+---
+
+### Pattern 4: Card Internal Spacing
+
+```tsx
+// ✅ CORRECT
+
+
+ Title
+ Description
+
+
+
Paragraph 1
+
Paragraph 2
+
+
+
+
+
+```
+
+**Spacing breakdown:**
+- `p-6` on Card: 24px internal padding
+- `space-y-4` on CardContent: 16px between paragraphs
+- `pt-4` on CardFooter: Additional top padding for visual separation
+
+---
+
+### Pattern 5: Page Layout
+
+```tsx
+// ✅ CORRECT
+
+```
+
+**Spacing breakdown:**
+- `px-4`: Horizontal padding (prevents edge touching)
+- `py-8`: Vertical padding (top and bottom spacing)
+- `space-y-6`: 24px between sections
+- No margins on children
+
+---
+
+## Before/After Examples
+
+### Example 1: Button Group
+
+#### ❌ Before (Child-Controlled)
+```tsx
+function ActionButton({ children, className }: Props) {
+ return ;
+}
+
+// Usage
+
+ Cancel
+ Save
+ Delete {/* Unwanted mr-4 */}
+
+```
+
+**Problems:**
+- Last button has unwanted margin
+- Can't change spacing without modifying component
+- Hard to use in vertical layout
+
+#### ✅ After (Parent-Controlled)
+```tsx
+function ActionButton({ children, className }: Props) {
+ return ;
+}
+
+// Usage
+
+ Cancel
+ Save
+ Delete
+
+
+// Different context: vertical
+
+ Cancel
+ Save
+
+```
+
+**Benefits:**
+- No edge cases
+- Reusable in any layout
+- Easy to change spacing
+
+---
+
+### Example 2: List Items
+
+#### ❌ Before (Child-Controlled)
+```tsx
+function ListItem({ title, description }: Props) {
+ return (
+
+
{title}
+
{description}
+
+ );
+}
+
+
+
+
+ {/* Unwanted mb-6 */}
+
+```
+
+**Problems:**
+- Last item has unwanted bottom margin
+- Can't change list spacing without modifying component
+- Internal `mb-2` hard to override
+
+#### ✅ After (Parent-Controlled)
+```tsx
+function ListItem({ title, description }: Props) {
+ return (
+
+
+
{title}
+
{description}
+
+
+ );
+}
+
+
+
+
+
+
+
+// Different context: compact spacing
+
+
+
+
+```
+
+**Benefits:**
+- No unwanted margins
+- Internal spacing controlled by `space-y-2`
+- Reusable with different spacings
+
+---
+
+### Example 3: Form Fields
+
+#### ❌ Before (Mixed Strategy)
+```tsx
+
+```
+
+**Problems:**
+- Spacing scattered across children
+- Hard to change consistently
+- Have to remember `mt-6` for button
+
+#### ✅ After (Parent-Controlled)
+```tsx
+
+```
+
+**Benefits:**
+- Spacing controlled in 2 places: form (`space-y-4`) and field groups (`space-y-2`)
+- Easy to change all field spacing at once
+- Consistent and predictable
+
+---
+
+## Anti-Patterns to Avoid
+
+### Anti-Pattern 1: Last Child Special Case
+
+```tsx
+// ❌ WRONG
+{items.map((item, index) => (
+
+ {item.name}
+
+))}
+
+// ✅ CORRECT
+
+ {items.map(item => (
+ {item.name}
+ ))}
+
+```
+
+---
+
+### Anti-Pattern 2: Negative Margins to Fix Spacing
+
+```tsx
+// ❌ WRONG - Using negative margin to fix unwanted spacing
+
{/* Canceling out previous margin */}
+ Content
+
+
+// ✅ CORRECT - Parent controls spacing
+
+ Content
+
+```
+
+**Why negative margins are bad:**
+- Indicates broken spacing strategy
+- Hard to maintain
+- Creates coupling between components
+
+---
+
+### Anti-Pattern 3: Mixing Gap and Child Margins
+
+```tsx
+// ❌ WRONG - Gap + child margins = unpredictable spacing
+
+ {/* gap + mr-2 = 24px */}
+
+
+
+// ✅ CORRECT - Only gap
+
+
+
+
+
+// ✅ CORRECT - Exception case
+
+
+ {/* Intentional extra space */}
+
+
+```
+
+---
+
+### Anti-Pattern 4: Using Margins for Layout
+
+```tsx
+// ❌ WRONG - Using margins to create layout
+
+
{/* Pushing content for sidebar */}
+ Content
+
+
+
+// ✅ CORRECT - Use proper layout (flex/grid)
+
+
+ Content
+
+```
+
+---
+
+## Quick Reference
+
+### Spacing Method Cheat Sheet
+
+| Use Case | Method | Example |
+|----------|--------|---------|
+| **Flex siblings** | `gap-*` | `flex gap-4` |
+| **Grid siblings** | `gap-*` | `grid gap-6` |
+| **Vertical stack** | `space-y-*` | `space-y-4` |
+| **Horizontal stack** | `space-x-*` | `space-x-2` |
+| **Inside component** | `p-*` | `p-6` |
+| **One child exception** | `m-*` | `mt-8` |
+
+### Common Spacing Values
+
+| Class | Pixels | Usage |
+|-------|--------|-------|
+| `gap-2` or `space-y-2` | 8px | Tight (label + input) |
+| `gap-4` or `space-y-4` | 16px | Standard (form fields) |
+| `gap-6` or `space-y-6` | 24px | Sections (cards) |
+| `gap-8` or `space-y-8` | 32px | Large gaps |
+| `p-4` | 16px | Standard padding |
+| `p-6` | 24px | Card padding |
+| `px-4 py-8` | 16px / 32px | Page padding |
+
+### Decision Flowchart (Simplified)
+
+```
+Need spacing?
+│
+├─ Between siblings?
+│ ├─ Flex/Grid parent? → gap-*
+│ └─ Regular parent? → space-y-* or space-x-*
+│
+├─ Inside component? → p-*
+│
+└─ Exception case? → m-* (sparingly)
+```
+
+---
+
+## Best Practices Summary
+
+### Do ✅
+
+1. **Use parent-controlled spacing** (`gap`, `space-y`, `space-x`)
+2. **Use `gap-*` for flex and grid** layouts
+3. **Use `space-y-*` for vertical stacks** (forms, content)
+4. **Use `p-*` for internal spacing** (padding inside components)
+5. **Use margin only for exceptions** (mt-8 to separate sections)
+6. **Let components be context-agnostic** (no built-in margins)
+
+### Don't ❌
+
+1. ❌ Add margins to reusable components
+2. ❌ Use last-child selectors or conditional margins
+3. ❌ Mix gap with child margins
+4. ❌ Use negative margins to fix spacing
+5. ❌ Use margins for layout (use flex/grid)
+6. ❌ Hard-code spacing in child components
+
+---
+
+## Spacing Checklist
+
+Before implementing spacing, verify:
+
+- [ ] **Parent controls children?** Using gap or space-y/x?
+- [ ] **No child margins?** Components don't have mb-* or mr-*?
+- [ ] **Consistent method?** Not mixing gap + child margins?
+- [ ] **Reusable components?** Work in different contexts?
+- [ ] **No edge cases?** No last-child or first-child special handling?
+- [ ] **Semantic spacing?** Using design system scale (4, 8, 12, 16...)?
+
+---
+
+## Next Steps
+
+- **Practice**: Refactor existing components to use parent-controlled spacing
+- **Explore**: [Interactive spacing examples](/dev/spacing)
+- **Reference**: [Quick Reference Tables](./99-reference.md)
+- **Layout Patterns**: [Layouts Guide](./03-layouts.md)
+
+---
+
+**Related Documentation:**
+- [Layouts](./03-layouts.md) - When to use Grid vs Flex
+- [Foundations](./01-foundations.md) - Spacing scale tokens
+- [Component Creation](./05-component-creation.md) - Building reusable components
+- [Quick Start](./00-quick-start.md) - Essential patterns
+
+**Last Updated**: November 2, 2025
diff --git a/frontend/docs/design-system/05-component-creation.md b/frontend/docs/design-system/05-component-creation.md
new file mode 100644
index 0000000..b872135
--- /dev/null
+++ b/frontend/docs/design-system/05-component-creation.md
@@ -0,0 +1,874 @@
+# Component Creation Guide
+
+**Learn when to create custom components vs composing existing ones**, and master the patterns for building reusable, accessible components with variants using CVA (class-variance-authority).
+
+---
+
+## Table of Contents
+
+1. [When to Create vs Compose](#when-to-create-vs-compose)
+2. [Component Templates](#component-templates)
+3. [Variant Patterns (CVA)](#variant-patterns-cva)
+4. [Prop Design](#prop-design)
+5. [Testing Checklist](#testing-checklist)
+6. [Real-World Examples](#real-world-examples)
+
+---
+
+## When to Create vs Compose
+
+### The Golden Rule
+
+**80% of the time, you should COMPOSE existing shadcn/ui components.**
+
+Only create custom components when:
+1. ✅ You're reusing the same composition 3+ times
+2. ✅ The pattern has complex business logic
+3. ✅ You need variants beyond what shadcn/ui provides
+
+---
+
+### Decision Tree
+
+```
+Do you need a UI element?
+│
+├─ Does shadcn/ui have this component?
+│ │
+│ ├─YES─> Use it directly
+│ │
+│ │
+│ └─NO──> Can you compose multiple shadcn/ui components?
+│ │
+│ ├─YES─> Compose them inline first
+│ │
+│ │ ...
+│ │
+│ │
+│ └─NO──> Are you using this composition 3+ times?
+│ │
+│ ├─NO──> Keep composing inline
+│ │
+│ └─YES─> Create a custom component
+│ function MyComponent() { ... }
+```
+
+---
+
+### ✅ GOOD: Compose First
+
+```tsx
+// ✅ CORRECT - Compose inline
+
+
+ {title}
+ {description}
+
+
+
{content}
+
+
+
+
+
+```
+
+**Why this is good:**
+- Simple and direct
+- Easy to customize per use case
+- No abstraction overhead
+- Clear what's happening
+
+---
+
+### ❌ BAD: Over-Abstracting Too Soon
+
+```tsx
+// ❌ WRONG - Premature abstraction
+function ContentCard({ title, description, content, actionLabel, onAction }: Props) {
+ return (
+
+
+ {title}
+ {description}
+
+
+
{content}
+
+
+
+
+
+ );
+}
+
+// Used once... why did we create this?
+
+```
+
+**Problems:**
+- ❌ Created before knowing if pattern is reused
+- ❌ Inflexible (what if we need 2 buttons?)
+- ❌ Unclear what it renders (abstraction hides structure)
+- ❌ Harder to customize
+
+---
+
+### ✅ GOOD: Extract After 3+ Uses
+
+```tsx
+// ✅ CORRECT - After seeing pattern used 3 times, extract
+function DashboardMetricCard({
+ title,
+ value,
+ change,
+ icon: Icon,
+}: DashboardMetricCardProps) {
+ return (
+
+
+ {title}
+ {Icon && }
+
+
+
{value}
+ {change && (
+
+ {change > 0 ? '+' : ''}{change}% from last month
+
+ )}
+
+
+ );
+}
+
+// Now used in 5+ places
+
+
+```
+
+**Why this works:**
+- ✅ Pattern validated (used 3+ times)
+- ✅ Specific purpose (dashboard metrics)
+- ✅ Consistent structure across uses
+- ✅ Easy to update all instances
+
+---
+
+## Component Templates
+
+### Template 1: Basic Custom Component
+
+**Use case**: Simple component with optional className override
+
+```tsx
+import { cn } from '@/lib/utils';
+
+interface MyComponentProps {
+ className?: string;
+ children: React.ReactNode;
+}
+
+export function MyComponent({ className, children }: MyComponentProps) {
+ return (
+
+
+
+ Sign In
+ Enter your credentials to continue
+
+
+
+
+
+
+```
+
+---
+
+### Two-Column Form
+
+```tsx
+
+```
+
+---
+
+### Form with Sections
+
+```tsx
+
+```
+
+---
+
+## Advanced Patterns
+
+### Dynamic Fields (Array)
+
+```tsx
+import { useFieldArray } from 'react-hook-form';
+
+const schema = z.object({
+ items: z.array(z.object({
+ name: z.string().min(1),
+ quantity: z.coerce.number().min(1),
+ })).min(1, 'At least one item required'),
+});
+
+function DynamicForm() {
+ const form = useForm({
+ resolver: zodResolver(schema),
+ defaultValues: {
+ items: [{ name: '', quantity: 1 }],
+ },
+ });
+
+ const { fields, append, remove } = useFieldArray({
+ control: form.control,
+ name: 'items',
+ });
+
+ return (
+
+ );
+}
+```
+
+---
+
+### Conditional Fields
+
+```tsx
+const schema = z.object({
+ role: z.enum(['user', 'admin']),
+ adminKey: z.string().optional(),
+}).refine((data) => {
+ if (data.role === 'admin') {
+ return !!data.adminKey;
+ }
+ return true;
+}, {
+ message: 'Admin key required',
+ path: ['adminKey'],
+});
+
+function ConditionalForm() {
+ const form = useForm({ resolver: zodResolver(schema) });
+ const role = form.watch('role');
+
+ return (
+
+ );
+}
+```
+
+---
+
+### File Upload
+
+```tsx
+const schema = z.object({
+ file: z.instanceof(FileList).refine((files) => files.length > 0, {
+ message: 'File is required',
+ }),
+});
+
+
+
+const onSubmit = (data: FormData) => {
+ const file = data.file[0]; // FileList -> File
+ const formData = new FormData();
+ formData.append('file', file);
+ // Upload formData
+};
+```
+
+---
+
+## Form Checklist
+
+Before shipping a form, verify:
+
+### Functionality
+- [ ] All fields register correctly
+- [ ] Validation works (test invalid inputs)
+- [ ] Submit handler fires
+- [ ] Loading state works
+- [ ] Error messages display
+- [ ] Success case redirects/shows success
+
+### Accessibility
+- [ ] Labels associated with inputs (`htmlFor` + `id`)
+- [ ] Error messages use `aria-describedby`
+- [ ] Invalid inputs have `aria-invalid`
+- [ ] Focus order is logical (Tab through form)
+- [ ] Submit button disabled during submission
+
+### UX
+- [ ] Field errors appear on blur or submit
+- [ ] Loading state prevents double-submit
+- [ ] Success message or redirect on success
+- [ ] Cancel button clears form or navigates away
+- [ ] Mobile-friendly (responsive layout)
+
+---
+
+## Next Steps
+
+- **Interactive Examples**: [Form examples](/dev/forms)
+- **Components**: [Form components](./02-components.md#form-components)
+- **Accessibility**: [Form accessibility](./07-accessibility.md#forms)
+
+---
+
+**Related Documentation:**
+- [Components](./02-components.md) - Input, Label, Button, Select
+- [Layouts](./03-layouts.md) - Form layout patterns
+- [Accessibility](./07-accessibility.md) - ARIA attributes for forms
+
+**External Resources:**
+- [react-hook-form Documentation](https://react-hook-form.com)
+- [Zod Documentation](https://zod.dev)
+
+**Last Updated**: November 2, 2025
diff --git a/frontend/docs/design-system/07-accessibility.md b/frontend/docs/design-system/07-accessibility.md
new file mode 100644
index 0000000..b1a1dcc
--- /dev/null
+++ b/frontend/docs/design-system/07-accessibility.md
@@ -0,0 +1,704 @@
+# Accessibility Guide
+
+**Build inclusive, accessible interfaces** that work for everyone. Learn WCAG AA standards, keyboard navigation, screen reader support, and testing strategies.
+
+---
+
+## Table of Contents
+
+1. [Accessibility Standards](#accessibility-standards)
+2. [Color Contrast](#color-contrast)
+3. [Keyboard Navigation](#keyboard-navigation)
+4. [Screen Reader Support](#screen-reader-support)
+5. [ARIA Attributes](#aria-attributes)
+6. [Focus Management](#focus-management)
+7. [Testing](#testing)
+8. [Accessibility Checklist](#accessibility-checklist)
+
+---
+
+## Accessibility Standards
+
+### WCAG 2.1 Level AA
+
+We follow **WCAG 2.1 Level AA** as the **minimum** standard.
+
+**Why Level AA?**
+- ✅ Required for most legal compliance (ADA, Section 508)
+- ✅ Covers 95%+ of accessibility needs
+- ✅ Achievable without major UX compromises
+- ✅ Industry standard for modern web apps
+
+**WCAG Principles (POUR):**
+1. **Perceivable** - Information can be perceived by users
+2. **Operable** - Interface can be operated by users
+3. **Understandable** - Information and operation are understandable
+4. **Robust** - Content works with current and future technologies
+
+---
+
+### Accessibility Decision Tree
+
+```
+Creating a UI element?
+│
+├─ Is it interactive?
+│ ├─YES─> Can it be focused with Tab?
+│ │ ├─YES─> ✅ Good
+│ │ └─NO──> ❌ Add tabIndex or use button/link
+│ │
+│ └─NO──> Is it important information?
+│ ├─YES─> Does it have appropriate semantic markup?
+│ │ ├─YES─> ✅ Good
+│ │ └─NO──> ❌ Use h1-h6, p, ul, etc.
+│ │
+│ └─NO──> Is it purely decorative?
+│ ├─YES─> Add aria-hidden="true"
+│ └─NO──> Add alt text or ARIA label
+```
+
+---
+
+## Color Contrast
+
+### Minimum Contrast Ratios (WCAG AA)
+
+| Content Type | Minimum Ratio | Example |
+|--------------|---------------|---------|
+| **Normal text** (< 18px) | **4.5:1** | Body paragraphs, form labels |
+| **Large text** (≥ 18px or ≥ 14px bold) | **3:1** | Headings, subheadings |
+| **UI components** | **3:1** | Buttons, form borders, icons |
+| **Graphical objects** | **3:1** | Chart elements, infographics |
+
+**WCAG AAA (ideal, not required):**
+- Normal text: 7:1
+- Large text: 4.5:1
+
+---
+
+### Testing Color Contrast
+
+**Tools:**
+- [WebAIM Contrast Checker](https://webaim.org/resources/contrastchecker/)
+- Chrome DevTools: Inspect element → Accessibility panel
+- [Contrast Ratio Tool](https://contrast-ratio.com)
+- Browser extensions: axe DevTools, WAVE
+
+**Example:**
+
+```tsx
+// ✅ GOOD - 4.7:1 contrast (WCAG AA pass)
+
// oklch(0.1529 0 0) on white
+ Body text
+
+
+// ❌ BAD - 2.1:1 contrast (WCAG AA fail)
+
// Too light
+ Body text
+
+
+// ✅ GOOD - Using semantic tokens ensures contrast
+
+ Secondary text
+
+```
+
+**Our design system tokens are WCAG AA compliant:**
+- `text-foreground` on `bg-background`: 12.6:1 ✅
+- `text-primary-foreground` on `bg-primary`: 8.2:1 ✅
+- `text-destructive` on `bg-background`: 5.1:1 ✅
+- `text-muted-foreground` on `bg-background`: 4.6:1 ✅
+
+---
+
+### Color Blindness
+
+**8% of men and 0.5% of women** have some form of color blindness.
+
+**Best practices:**
+- ❌ Don't rely on color alone to convey information
+- ✅ Use icons, text labels, or patterns in addition to color
+- ✅ Test with color blindness simulators
+
+**Example:**
+
+```tsx
+// ❌ BAD - Color only
+
Success
+
Error
+
+// ✅ GOOD - Color + icon + text
+
+
+ Success
+ Operation completed
+
+
+
+
+ Error
+ Something went wrong
+
+```
+
+---
+
+## Keyboard Navigation
+
+### Core Requirements
+
+All interactive elements must be:
+1. ✅ **Focusable** - Can be reached with Tab key
+2. ✅ **Activatable** - Can be triggered with Enter or Space
+3. ✅ **Navigable** - Can move between with arrow keys (where appropriate)
+4. ✅ **Escapable** - Can be closed/exited with Escape key
+
+---
+
+### Tab Order
+
+**Natural tab order** follows DOM order (top to bottom, left to right).
+
+```tsx
+// ✅ GOOD - Natural tab order
+
+
+// ❌ BAD - Using tabIndex to force order
+
+```
+
+**When to use `tabIndex`:**
+- `tabIndex={0}` - Make non-interactive element focusable
+- `tabIndex={-1}` - Remove from tab order (for programmatic focus)
+- `tabIndex={1+}` - ❌ **Avoid** - Breaks natural order
+
+---
+
+### Keyboard Shortcuts
+
+| Key | Action | Example |
+|-----|--------|---------|
+| **Tab** | Move focus forward | Navigate through form fields |
+| **Shift + Tab** | Move focus backward | Go back to previous field |
+| **Enter** | Activate button/link | Submit form, follow link |
+| **Space** | Activate button/checkbox | Toggle checkbox, click button |
+| **Escape** | Close overlay | Close dialog, dropdown |
+| **Arrow keys** | Navigate within component | Navigate dropdown items |
+| **Home** | Jump to start | First item in list |
+| **End** | Jump to end | Last item in list |
+
+---
+
+### Implementing Keyboard Navigation
+
+**Button (automatic):**
+```tsx
+// ✅ Button is keyboard accessible by default
+
+// Enter or Space triggers onClick
+```
+
+**Custom clickable div (needs work):**
+```tsx
+// ❌ BAD - Not keyboard accessible
+