AGENT SKILL

brand-ui-enterprise

Design-judgment layer for building enterprise-grade app UIs with the brand-ui (@elabs-ai/components-*) design system. Use when designing or laying out a professional/business app or screen — admin console, operator console, internal/back-office tool, dashboard, data app, dense data table, master-detail/drill-down screen, B2B SaaS app, or AI workspace — that must read enterprise-grade, not like a marketing or consumer app. It classifies the surface (professional vs consumer vs marketing) and commits to a register, picks the app-shell archetype (tool/workspace vs enterprise admin), models objects and screens, and stands up the mandatory baseline (shell, app icon + favicon, System/Light/Dark theme switcher, settings modal, toasts, detail panel). Also triggers on app-shell design and admin/dashboard layout. Not for marketing landing pages, consumer/mobile apps, pure data/SQL/analytics questions, theme-token-only work, or component-library picks; defers props to brand-ui and scored review to brand-ui-audit.

License 许可
MIT
最近更新
2026-10-07
Stars
★ 1
Forks
1

01 前言 Front Matter

name
brand-ui-enterprise
description
Design-judgment layer for building enterprise-grade app UIs with the brand-ui (@elabs-ai/components-*) design system. Use when designing or laying out a professional/business app or screen — admin console, operator console, internal/back-office tool, dashboard, data app, dense data table, master-detail/drill-down screen, B2B SaaS app, or AI workspace — that must read enterprise-grade, not like a marketing or consumer app. It classifies the surface (professional vs consumer vs marketing) and commits to a register, picks the app-shell archetype (tool/workspace vs enterprise admin), models objects and screens, and stands up the mandatory baseline (shell, app icon + favicon, System/Light/Dark theme switcher, settings modal, toasts, detail panel). Also triggers on app-shell design and admin/dashboard layout. Not for marketing landing pages, consumer/mobile apps, pure data/SQL/analytics questions, theme-token-only work, or component-library picks; defers props to brand-ui and scored review to brand-ui-audit.
allowed-tools
[ "Bash(npx @elabs-ai/components-cli *)", "Bash(npx brand-ui *)", "Bash(pnpm brand-ui *)" ]
argument-hint
[what you're building, e.g. 'internal admin console for billing ops, dark']
user-invocable
true

02 资源文件 59

03 SKILL.md 正文

brand-ui-enterprise

Design enterprise-grade applications with brand-ui. This skill is the judgment layer: decide what kind of product you're building, pick the right shell, stand up the mandatory baseline, then build screens from @elabs-ai/components-* with enterprise UX discipline. Keep this file lean — load a reference/ file when its step is active.

What this skill owns — and defers

  • Owns: the professional / consumer / marketing call + register; the shell-archetype choice; the enterprise app baseline (definition of done); applying enterprise UX principles mapped to @elabs-ai/components-*.
  • Defers: real component props/APIs → the brand-ui skill (brand-ui search / brand-ui docs); scored UX/a11y review → brand-ui-audit (set its register = product/professional); a brand-new scaffold interview → brand-ui-new-app (feed it the shell archetype this skill picked — A tool/workspace or B enterprise admin); tokens/themes → brand-ui-theme.
  • Never: re-implement a component, invent props, or use marketing patterns in a professional surface.

Procedure (in order)

0 · Detect the mode (what situation am I in?)

Infer from the request + the workspace — don't interrogate:

  • Create (greenfield) · Extend (add to a brand-ui app) · Audit & fix (review / remediate an existing app) · Retrofit (bring a non-brand-ui app onto brand-ui).

Look first (package.json for @elabs-ai/components-*, an existing shell/routes); ask one question only if genuinely ambiguous. Each mode has its own short question set + hand-offs. → reference/modes-and-interaction.md.

1 · Classify the surface → state the register

Decide first: professional / consumer / marketing?

  • Professional — "a trained user does this repeatedly as their job" → calm register.
  • Consumer — "a stranger uses this voluntarily; we want them back" → lighter register.
  • Marketing — "a visitor is deciding whether to care; one action" → expressive register.

Say the answer out loud before building. Mixed product → classify per surface (the app shell is professional; a /landing or /pricing route is marketing). → reference/professional-vs-marketing.md (tests, table, the trap, legitimate exceptions).

2 · Pick the shell archetype + plan the nav

Professional apps use one of two shells — choose up front (hard to change later):

  • A — tool/workspace (editor / inspector / canvas): inset collapsible sidebar + routed content + status bar + navigator/inspector panes + ⌘K palette.
  • B — enterprise admin (console): icon sidebar (top-level views) + topnav + breadcrumb + optional secondary rail + detail.

Marketing → no sidebar; top nav + single scroll. → reference/shell-and-navigation.md (archetypes, nav-type catalog, canonical snippets).

3 · Stand up the baseline (mandatory, by default)

Every professional app gets these without being asked: the chosen shell, the collapsible brand app icon + favicon, ThemeProvider + System/Light/Dark switcher, a settings modal, the Sonner Toaster, and a right-side detail panel (generic Sheet/Drawer; @elabs-ai/components-ai ContextPanel for AI surfaces). → reference/enterprise-app-baseline.md (spec, root wiring, definition-of-done checklist).

4 · Model the objects & task flow, then build screens

Model first, lay out second (noun → verb): list the objects (Country, Customer, Order), their relationships, actions and attributes; give each object a detail hub (header + attributes + actions + related lists) and connect them with drill-down/up navigation (breadcrumb path, peer prev/next, preserved list position). Pick the detail/task surface by context + complexity + reference-need: full page (hub / multi-step) · drawer/Sheet (keep the list in view) · modal Dialog/AlertDialog (focused / irreversible) · inline/expand (repeated edits). Never dump everything onto one page. → reference/object-and-navigation-patterns.md.

Then prioritize by information value: rank each region (act › decide › reference › raw), match space + emphasis + interaction to importance, turn findings into actions, kill redundancy, order sections summary-first, and promote a high-value task to its own surface. → reference/information-priority-and-emphasis.md.

Before composing any single net-new screen, run the design-first ritual below ("Designing a net-new screen") — intent sentence, references, distinct concepts, a mocked concept, then the full state grid. Skipping straight to component assembly is exactly the function-first "list + card" failure this skill exists to prevent.

Then compose from @elabs-ai/components-* with enterprise discipline: density-with-progressive-disclosure, every state designed, calm token-only visuals, motion that explains state, fix-oriented copy. Real props: default to brand-ui docs/brand-ui search, or compose with documented props and flag what's unconfirmed — never guess. Deep-verifying against the vendored @elabs-ai/components-* source is optional (shipping-critical only), not an every-run step. → reference/principles.md.

5 · Verify → hand off

Run the baseline checklist (enterprise-app-baseline.md §3). Route a scored review to brand-ui-audit with register = product/professional (so it judges this as a professional product surface, not marketing). For a greenfield scaffold, hand brand-ui-new-app the shell archetype this skill picked (A tool/workspace or B enterprise admin) so it starts from the right shell. Report honestly what you did not visually verify (compiled ≠ looked at). → reference/modes-and-interaction.md (per-mode hand-offs).

Designing a net-new screen (run before scaffolding it)

Step 4's object model tells you WHAT screens exist; this is the ritual for HOW each one gets designed, not just assembled. Before writing app code for any net-new screen, page, or major surface:

  1. Intent, in one sentence. Who opens it, what do they leave with? Not "a directory of X" — "tells ops which orders need action today".
  2. 2–3 named references, looked up proactively (comparable products/screens), and what they do that this one should match or beat.
  3. 2–3 conceptually distinct concepts, not parameters of one composition — score against the intent, recommend one.
  4. Mock the recommended concept as a story before it becomes a real route/page.
  5. Design the full state grid with the happy path: Ready · Loading (Skeleton) · Empty (StatePanel/EmptyState) · Error (StatePanel/ErrorState, terminal only) · First-run — never retrofitted.
  6. The non-component layers: illustration (does this moment deserve one?), motion (what state change must be felt?), voice/microcopy (fix-oriented, specific), and information hierarchy (what reads first — is that right?).
  7. Close with a review, not a compile — route to brand-ui-audit before calling it shipped.

Component lists and prop budgets are the LAST step, never the first. Full checklist: reference/screen-design-brief.md.

Critical rules (always)

  • Classification-first. Never build before stating surface type + register.
  • Objects and tasks before pages. Model the objects (noun → verb), give each a detail hub, connect them with drill-down/up navigation. A screen operates on an object or completes a task — it is never a content-dump of everything on one page.
  • Right component for each structural job. Sticky PageShell/SectionHeader header with a ButtonGroup toolbar (not loose buttons); Tabs for an object's sections (not a card stack); SplitPanel master-detail when a list drives a detail (never detail below the list); a searchable list with a count (not hand-rolled cards). → screen-layout-patterns.md.
  • Importance drives emphasis, space & interaction. Rank every region by value to the task (act › decide › reference › raw); give the most valuable content the most space, prominence, and interaction; de-emphasize or hide reference/raw; kill redundancy (say each thing once); order sections summary-first; promote a high-value repeated task (e.g. Run X) to its own surface. → information-priority-and-emphasis.md.
  • The baseline is mandatory for professional apps — not opt-in.
  • Professional register discipline: dense-by-design + progressive disclosure; calm, token-only visuals; motion explains state (<~200 ms, motion-reduce safe).
  • No marketing slop in a pro surface: no hero/landing layout, no wall of three equal feature cards, no gradient/"AI-purple" accents, no fake-perfect stats, no "Acme / Jane Doe" content, no filler verbs (elevate, seamless, unleash…).
  • Semantic tokens only; must read in light and dark. Real elements, visible focus, labels, aria-label on icon-only controls.
  • Compose, don't reinvent. Defer APIs to brand-ui; defer scoring to brand-ui-audit.
  • Lean by default. Load only the active step's reference/*.md, not all of them; deep prop-verification against the vendored @elabs-ai/components-* source is opt-in (shipping-critical only) — the default is brand-ui docs or compose-and-flag. Don't turn every run into a full audit.

The category error this skill prevents

"Build an internal admin console for X" must not produce a marketing landing (hero banner, three equal cards, big gradient headline, fake stats). An admin console is a professional surface → archetype B + the baseline. Reaching for @elabs-ai/components-marketing in an operational app? Stop and re-do step 1.

Resources

  • reference/modes-and-interaction.md — the four modes, mode detection, per-mode question sets, hand-offs.
  • reference/professional-vs-marketing.md — the 3-way framework, one-line tests, the trap.
  • reference/shell-and-navigation.md — shell archetypes A/B, nav-type catalog, snippets (collapsible app icon, theme switcher, settings modal) distilled from shipping enterprise apps.
  • reference/enterprise-app-baseline.md — the mandatory default skeleton + checklist.
  • reference/screen-design-brief.md — the design-first ritual for a net-new screen: intent → references → distinct concepts → mocked concept → full state grid → non-component layers → review, before component assembly.
  • reference/principles.md — enterprise UX principles (rulebook) → @elabs-ai/components-* map.
  • reference/object-and-navigation-patterns.md — OOUI, object detail hubs, drill-down/up navigation, and the detail-surface decision tree (page/drawer/modal/inline) → @elabs-ai/components-*.
  • reference/screen-layout-patterns.md — screen anatomy, structural component selection, master-detail split, and the MCP-server case study (what goes where, in which component).
  • reference/information-priority-and-emphasis.md — rank content by value; emphasis/space/ interaction by importance; insight→action; promote high-value tasks to their own surface.
  • assets/ — paste-ready baseline files (app shell, theme switcher, settings modal, providers, favicon) and a detail-hub.tsx screen example (archetype-B object detail hub: sticky header+tabs · SplitPanel master-detail · Run-task Dialog) — starting points; verify props with brand-ui docs.

Sibling brand-ui skills do the rest: brand-ui (compose + real APIs), brand-ui-new-app (scaffold), brand-ui-audit (scored review), brand-ui-theme (tokens/themes). Shipped as brand-ui-enterprise; vendored from an internal, first-party enterprise-UI skill repo (v0.4.0).

04 同仓库更多 Skills

mreimitz
mreimitz/elabs-components

brand-ui

Build UI with the brand-ui component system (@elabs-ai/components-* packages — ui, data, ai, flow, maps, charts, marketing, editor, viewer, terminal, tokens, icons). Use when working in a project that depends on @elabs-ai/components-ui or any @elabs-ai/components-* package, when adding/composing components, building dashboards, data tables, AI/chat surfaces, React Flow canvases, MapLibre maps, code editors, file/document viewers, app shells, forms, or marketing sections, when theming with the token system, or when the user mentions brand-ui, @brand, light/dark themes, or "our design system". Provides live project context, the real component API, composition patterns, and the rules that keep components token-driven, accessible, and theme-safe.

★ 1
mreimitz
mreimitz/elabs-components

brand-ui-update-theme

Use when an existing brand-ui theme family should be improved from new material — updated brand guidelines, a new logo, product screenshots, a live site, feedback like "the green is off" or "match their new design system" — e.g. "update the qlik theme with these links", "refresh our theme from the new brand book", "/update-theme". For a brand with no theme yet, use brand-ui-create-theme.

★ 1
mreimitz
mreimitz/elabs-components

brand-ui-theme

Create or retune a brand-ui theme (token work). Use when adding a new theme, re-branding the system to a customer's palette, adjusting global radius/spacing/surfaces, or fixing token-level contrast across themes. Use when the user says "new theme", "brand it for <customer>", "make corners less rounded", "dark theme", "adjust the tokens", or "our colors". Every change is a token in a theme stylesheet — never a hardcoded value in a component.

★ 1
mreimitz
mreimitz/elabs-components

brand-ui-start

The front door for building UI with brand-ui — a router/concierge that asks what you want to do and hands you to the right flow. Use when someone is starting out and unsure where to begin ("help me with brand-ui", "where do I start", "I want to build something", "what can brand-ui do", "get me going"), or types /brand-ui-start. Routes to three flows — build a NEW app (brand-ui-new-app), improve/migrate an EXISTING app (brand-ui-migrate), or just help me USE brand-ui in an app that already has it (brand-ui). If the intent is already obvious (the person said "build me a dashboard" or "audit this screen"), skip the question and go straight to that flow.

★ 1
mreimitz
mreimitz/elabs-components

brand-ui-registry

Curate the brand-ui shadcn-compatible registry (maintainer workflow). Use when deciding whether something belongs as an imported @elabs-ai/components-* primitive vs a copy-own registry block/template, when adding or editing a registry item, or when validating/building the registry for distribution. Use when the user says "add a registry item", "make this a block", "publish to the registry", or "package vs registry". For consuming registry items in an app, use the `brand-ui` skill (npx shadcn add).

★ 1
mreimitz
mreimitz/elabs-components

brand-ui-new-app

Define-to-build — scaffold a new brand-ui app from a plain-language description (VP-02). Use when the user wants to START an app, page, or demo ("build me a sales dashboard", "I need an admin console for X", "new app", "scaffold a chat assistant", "create a landing page for a pitch") rather than add to an existing one. Runs a staged interview (quick 3-question mode or full 7-stage spec mode), writes an app-spec.md, then scaffolds from the matching template + playbook with every wiring point annotated and a starter CLAUDE.md so later agent sessions stay on-brand. For adding components to an existing app use `brand-ui`; for authoring library components use `brand-ui-component`.

★ 1