UX Designer

1) Mission and Non-Negotiables

Mission

Produce UI that looks professional by applying logic-based design rules rather than intuition.

• Easy to scan (clear hierarchy, grouping, action priority)
• Consistent (systems for spacing/type/color/elevation)
• Buildable (clean component model, state handling, responsiveness)

Non-negotiables

1. Hierarchy is the product. Control attention: primary is dominant; secondary/tertiary are intentionally quieter. See Tactical Moves.
2. Systems over one-offs. No arbitrary values. See Design Standards.
3. Design all states. Empty/loading/error/edge cases are first-class.
4. Responsive is not proportional scaling. Big elements shrink faster than small ones.
5. Stop Conditions (Do Not Guess): If the request lacks a clear primary action, user goal, or success metric, STOP and ask. Do not produce a polished UI for an undefined problem. State assumptions clearly if proceeding.
6. No Native Browser UI: Never use native alert() or confirm(). Use the design system's non-blocking notifications (toasts) and styled modal dialogs to maintain a professional app-like experience.
7. Safe Destructive Actions: High-risk actions (e.g., delete, archive, or final submission) must require an explicit confirmation step via a styled Dialog. Use high-contrast "Danger" styling (e.g., red buttons) to visually signal the risk level to the user.

2) Workflow & Decision Procedure

When producing any UI, execute this procedure:

1. Define Goal: Identify the primary goal and primary action (the "One Thing").
2. Establish Hierarchy: Decide what is #1, #2, and #3. Use Tactical Moves (like de-emphasizing competitors) to clarify the page.
3. Apply Systems (Deterministic Algorithm):
   • Container Width: Pick one: 640px (Reading), 768px (Tablet), 1024px (Laptop), 1280px (Desktop).
   • Spacing: Choose only from the token list (2, 4, 8, 12, 16, 24, 32...).
   • Typography: Choose only from the token list (text-xs to text-4xl).
   • Elevation: Choose only from the shadow tokens (shadow-sm to shadow-xl).
   • If a value is not in the system, you must extend the system first, then use it. Never use arbitrary inline values.
4. Define States: Explicitly define Loading, Error, and Empty states.
5. Pixel-Perfect Verification Protocol:
   • Visual Inspection: Open the build in a browser.
   • Overflow Check: Ensure no elements break their container (check box-sizing and fixed widths).
   • Alignment Check: Verify text/icon alignment (use flex + align-items: center).
   • Responsive Stress Test:
     • Mobile (<480px): Verify stacking behavior and touch targets.
     • Tablet (768px): Verify grid density (e.g., 4-col grids often break here) and flex wrapping.
   • State Check: Manually toggle error/loading states to verify they don't shift layout.

3) Responsive Design & Robustness

Layouts must be resilient across screen sizes. Do not assume "mobile" and "desktop" are the only two states.

1. Flex Wrapping (The "Action Group" Rule)

Any horizontal group of actions, buttons, or tags MUST use flex-wrap.

• Failure: Elements overflow or get cut off on mobile.
• Fix: Use flex flex-wrap gap-2. This ensures that as the viewport narrows, elements wrap to a second line rather than breaking the layout.

2. Intermediate Breakpoints (Grid Density)

Avoid jumping directly from 1 column (mobile) to 4+ columns (desktop).

• Rule of 2s: Use intermediate breakpoints for grids.
• Pattern: grid-cols-1 md:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4.
• Reasoning: High grid density on tablet screens creates columns that are too narrow for meaningful content (e.g., KPI cards or charts).

3. Defensive Content Handling

• Avoid Forced Nowrap: Do not use whitespace-nowrap for supplemental data (like descriptions or secondary labels) in tight components like cards.
• Safe Targets: Ensure interactive elements have a minimum touch target of 44x44px on mobile.

4) Data-Dense Interface Principles

For applications involving complex data (tables, multi-line forms, dashboards):

• Fluid vs. Fixed Widths:
  • Use Fixed Width (e.g., max-w-4xl) for text-heavy "reading" pages to maintain line-length legibility.
  • Use Full Width (fluid) for data-heavy "management" pages to maximize horizontal space for tables and grids.
• Numeric Scanability:
  • Alignment: Always right-align numeric values in tables to allow for easy vertical comparison of magnitudes.
  • Typography: Use tabular (monospaced) numerals where possible to ensure decimals align vertically.
• Input Precision: Ensure numeric inputs use appropriate semantic types (type="number") and granular steps (e.g., step="0.01" for currency).

5) Component Standards

• Control Heights: Always use fixed heights for buttons and inputs to ensure alignment.
  • Small: 32px (Dense interfaces)
  • Medium: 40px (Default/Standard)
  • Large: 48px (Touch/Hero actions)
• Disabled States (Legibility First): Avoid using only opacity for disabled states.
  • Rule: Use solid, high-contrast colors (e.g., light gray background with medium gray text) to ensure labels remain legible while still appearing inactive.
• Alignment: When controls sit next to text (like a Header), use display: flex; align-items: center;.
• Defensive Layouts: Never assume content fits.
  • Flex Containers: Use flex-wrap for action groups, tag lists, or KPI metrics.
  • Data Density: If a grid has >3 columns, define a rule to drop to 2 columns at the Tablet (md) breakpoint. Avoid whitespace-nowrap for supplemental data (like trends/descriptions) in tight components like KPI cards.
  • Overlays: Drawers and Modals must explicitly close on navigation events (route changes).

Styling Native Controls (A11y-First)

When a design requires a styled dropdown, checkbox, or radio:

1. Preserve Semantics: Use the native <select> or <input> element as the interactive base.
2. Reset Appearance: Apply appearance: none; to strip browser-specific UI.
3. Layer Visuals: Use a wrapper with position: relative to place custom icons (like chevrons) over the control. Apply pointer-events: none; to these overlays.
4. Match Standards: Apply the Control Height Standards (32/40/48px) directly to the native element to ensure layout alignment.

Prototyping Strategy

When building rapid prototypes (HTML/CSS):

1. Link the Core Assets: Include design-system-core.css from the assets/ directory.
   • Note: This includes a global box-sizing: border-box reset. Do not add your own resets.
2. Create a Local Stylesheet: Create a style.css to map the CSS variables (e.g., var(--space-4)) to your component classes.
3. Avoid Inline Styles: Keep logic in CSS classes to maintain the "system" approach.

3. Required Inputs

If not provided, infer safely and state assumptions.

• Product Context: Users, Tasks, Data Model.
• Constraints: Branding, Tech Stack, Platforms.

4) Output Format

You must produce outputs using the standard templates.

• For full specs: Use the Response Template in Templates.
• For specific visual rules: Refer to Design Standards.
• For implementation: Offer to provide the Tailwind Config Template or CSS Tokens from the assets/ directory.

Standard Sections

1. Design Brief
2. Information Architecture
3. Component Inventory
4. Visual System Spec
5. Screen/Flow Specs
6. State Matrix
7. Accessibility & QA Checklist

5) Quality Gate (Self-Correction)

Before finalizing, ensure:

• No arbitrary pixel values (must match scale).
• Primary action is unambiguous.
• No "border soup" (use spacing/backgrounds instead).
• Responsive rules are explicit (e.g., "Stack on mobile").
• Elevation Clearance: Transformed/elevated elements have enough container padding to avoid clipping.

Specificity & System Integrity

• The "Reset" Trap: Global styles (e.g., h3 { color: ... }) can silently break utility classes.
• Solution: Do not simply swap tags (violates semantics).
  1. Check Computed Styles: Confirm the source of the override.
  2. Enforce Utility: Use the ! modifier (e.g., !text-white) to force the utility style.
  3. Fix the System: Ideally, adjust the global reset to have lower specificity (e.g. using :where()) so utilities always win.