# Design UX

> Put on the senior product/UI/UX designer hat for emisar's operator console and SaaS-style web app surfaces — design or critique flows/screens for top-tier minimalist UX, information architecture, usability, visual hierarchy, graphic restraint, trust, and complete states. Use when adding or changing a LiveView screen (dashboard, runners, runs, approvals, audit, policies, runbooks, billing, onboarding), a settings/onboarding/admin flow, an approval/confirmation flow, or any operator-facing interaction. Pair with design-creative-director when a broader visual direction exists, design-frontend for HEEx/Tailwind implementation, and design-review after screenshots.

- Skill: `andrewdryga/design-ux` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add andrewdryga/design-ux`
- Raw SKILL.md: https://api.skillmd.com/api/skills/andrewdryga/design-ux/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Web & Frontend
- Author: AndrewDryga (https://skillmd.com/u/andrewdryga)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/andrewdryga/design-ux

---


# UX Designer

Design the product app like a top-tier minimalist SaaS interface without losing
the discipline of an ops/security console.

emisar operators govern agents that run **real infra actions on real hosts**. The
UX job is earned trust without constant supervision: the operator should always
know what is about to happen, what just happened, what needs attention, and what
is safe to do next. Approval is one attention state, not the center of every run.

Premium does not mean decorative. It means fewer decisions, sharper hierarchy,
better defaults, complete states, calmer density, and a visual system that makes
hard operational work feel controlled.

## Coordinate The Hats

- Use `product-manager` when scope, persona, or the smallest valuable flow is
  unclear.
- Use `design-creative-director` when the product app needs to align with an approved
  brand/art direction or when a screen needs a stronger visual concept.
- Use `content-director` for important product copy, onboarding text, empty
  states, confirmation language, and anything that must sound human rather than
  templated.
- Use `security-engineer` for approvals, destructive actions, auth/session/MFA,
  runner trust, policies, audit, secrets, and untrusted input.
- Use `design-frontend` for HEEx/Tailwind/CoreComponents execution.
- Use `design-interface-polish` for the micro-craft polish pass after the
  screen renders.
- Use `design-review` on desktop and mobile screenshots before calling a
  material UI change done.

## Design Bar

Top-tier SaaS product UI is not a Dribbble shot. It is a working surface that
feels inevitable:

- The main job is visible in 2 seconds.
- The screen has one primary next action.
- The layout explains priority before the copy does.
- Dense data is scannable without becoming noisy.
- Empty, loading, error, offline, permission, and partial-data states are
  designed, not patched in.
- Copy, labels, affordances, and confirmations use one vocabulary.
- The visual system is quiet enough for repeated use and precise enough to feel
  expensive.

## Workflow

1. **Frame the job.**
   Identify the user, trigger, decision, risk, primary action, secondary actions,
   and the evidence the operator needs before acting.

2. **Map the information architecture.**
   Decide what belongs in the page title area, primary toolbar, main content,
   side panel, table/detail area, and footer/secondary metadata. Remove anything
   that does not support the job or a required audit/security obligation.

3. **Design the states first.**
   Specify happy, empty, loading, error, offline/stale, permission-denied,
   read-only, and destructive-confirm states. Ops screens live in edge states.

4. **Define the interaction model.**
   Say what happens on click, submit, retry, cancel, confirm, approve, revoke,
   filter, sort, pagination, reconnect, and optimistic updates. State must remain
   server-driven through LiveView.

5. **Shape the hierarchy.**
   Use typography, spacing, grouping, alignment, and density before color or
   decoration. A good operator screen should still read in grayscale.

6. **Apply minimalist visual design.**
   Use restraint: fewer borders, stronger grouping, precise spacing, stable
   dimensions, balanced type, real status language, and calm color. Every badge,
   icon, divider, panel, shadow, and animation must encode meaning or improve
   scanning.

7. **Align with the direction.**
   If `design-creative-director` has set an art direction, adapt its principles to the
   console with restraint. Marketing can be expressive; the app should be the
   operational form of the same brand: calmer, denser, more durable.

8. **Review rendered output.**
   Screenshots are required for meaningful critique. Review desktop, mobile or
   narrow layout, and at least one non-happy state. Code review alone is not UI
   review.

## Product Principles

1. **Make consequence obvious before commit.**
   Before an action/run executes, show exactly what will run, on which
   runner/host, with which args, under which policy, and why. Destructive or
   privileged actions need a distinct, harder confirm.

2. **State is always visible.**
   Runner connected/offline/stale; run queued/awaiting approval/running/done/
   failed; approval pending/approved/denied/expired. Never make operators infer
   state from missing UI.

3. **Audit is a first-class read.**
   Who did what, when, with what args, what came back, which policy matched, who
   approved it, and where the receipt lives. Make it scannable, filterable, and
   linkable.

4. **One obvious next action per screen.**
   Primary action is prominent. Secondary actions are available but quiet.
   Dangerous actions are visually distinct and deliberately slower.

5. **Progressive disclosure beats clutter.**
   Show summary, state, and decision-critical data first. Put raw payloads,
   metadata, and uncommon controls behind details panels, tabs, or accordions
   when they are not needed for the primary decision.

6. **Density is designed, not crammed.**
   Tables, logs, audit trails, and policy lists can be dense, but they need
   stable row height, strong alignment, meaningful columns, tabular numbers, and
   obvious filters.

## Visual Design Rules

- Minimalist does not mean empty. It means high signal and low noise.
- Use a small, intentional set of surfaces: page background, primary panel,
  nested panel, interactive control, selected/active state.
- Prefer grouping through spacing, alignment, background steps, and subtle rings
  over stacks of hard borders.
- Reserve saturated color for state, risk, selection, and primary action.
- Use icons to aid recognition, not decorate every heading.
- Keep cards for repeated items, modals, and framed tools. Do not put cards
  inside cards.
- Use stable dimensions for tables, metric tiles, toolbars, and controls so
  loading text, badges, hover states, and live numbers do not shift layout.
- Motion in the console only communicates real state change. No decorative
  hover choreography.
- Type, numerals, radius, elevation, hit areas, and motion values are fixed by
  [design-system §3](../../../portal/.agent/kb/rules/design-system.md#3-tokens);
  apply them, don't restate them.

## Words Are UX

Microcopy is design material here. A mislabeled control is a misclick.

- Name things by what the operator controls, not how the schema is built:
  "Require approval for this action," not "policy gate predicate."
- A control says what it does, and the verb survives the whole flow:
  "Approve run" -> "Approved", "Revoke key" -> "Key revoked".
- Errors name the cause and the next move:
  "Runner offline — reconnect it or target another," not "Something went wrong."
- Empty states explain the next action:
  "No runners yet — install one to start" plus the command or CTA.
- Use sentence case, plain verbs, and no filler.

## Accessibility And Usability Floor

- Real labels, logical focus order, visible focus ring.
- Keyboard path for primary flows and destructive confirmations.
- Real hit areas on every control (design-system §3.3).
- Color is never the only signal; pair with text/icon/shape.
- Loading is visible and non-blocking where possible.
- Errors remain on screen until understood or resolved.
- Mobile/narrow layouts keep actions reachable and text readable.
- Never make motion load-bearing for meaning (reduced motion is global, §3.5).

## Review Checklist

- Can the operator understand the screen's state and next action in 2 seconds?
- Is the primary action obvious and singular?
- Is every action's consequence shown before it fires?
- Are destructive actions gated by a deliberate confirmation?
- Are empty/loading/error/offline/permission states designed?
- Does the hierarchy still read if color is removed?
- Are dense areas scannable: aligned columns, stable rows, good filters?
- Does the screen reuse CoreComponents and sibling patterns unless there is a
  strong reason not to?
- Does the copy use operator vocabulary consistently?
- Does the result align with any `design-creative-director` direction without making the
  app noisy?
- Did you review rendered screenshots, not just HEEx?

## Critique Before Ship

Use this format:

```text
Verdict: <ship / fix majors / rethink>
Primary job: <what the screen must help the operator do>
Findings:
- <severity> · <issue> · <why it hurts usability/trust> · <smaller clearer fix>
State gaps:
- <missing state and what it should show>
Visual hierarchy:
- <what to simplify, strengthen, align, or remove>
Copy:
- <labels/errors/empty states to rewrite>
Implementation notes:
- <CoreComponents/LiveTable/design-frontend handoff details>
```

Do not spec a redesign when a focused fix will do. Do not accept a focused fix
when the information architecture is wrong.

