agentsclimarketplace

Design system

Skill rafa-js/product-designer/skills/design-system

Build, extend, audit, or govern a design system. Use when the user is starting a design system, adding components, defining tokens, writing contribution guidelines, or evaluating whether/how to invest in a system.From its SKILL.md

Install
npx -y skills add rafa-js/product-designer --skill design-system

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

  • no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
  • 1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

SKILL.md

4.4 KB, as published. Nobody here has run it

Design System Work

A design system is tokens + components + patterns + governance. Skip any layer and it rots.

First, ask: should you build one at all?

  • Build now: 2+ products, 2+ designers, recurring inconsistency, an engineering library that can consume it.
  • Delay: solo designer, pre-PMF, no engineering capacity to maintain a library, no documented design language to encode.

If "delay": recommend a token + component file in Figma instead of a formal system. Make this the explicit recommendation, not a fallback.

Inputs to confirm

  • Stage: greenfield system, extending an existing one, or auditing/refactoring.
  • Stack: Figma / Sketch / Penpot for design; React / SwiftUI / Compose etc. for code.
  • Team: how many designers? engineers? Who maintains the system?
  • Source of truth: is the design file or the code library canonical? (One must be.)

Method by stage

Greenfield (building from zero)

Build in this order. Don't skip:

  1. Tokens — color, spacing, type, radius, elevation, motion. See visual-language skill.
  2. Foundational components — Button, Input, Text, Icon. These unblock everything else.
  3. Layout primitives — Stack, Grid, Spacer. So no one writes margins by hand.
  4. Composite components — Card, Modal, Tabs, Toast, Menu, Tooltip.
  5. Patterns — Empty state pattern, Form pattern, Onboarding pattern. Documented as recipes, not separate components.

Document as you go; don't backfill. Component undocumented = component not real.

Extending an existing system

For each new component proposal:

  • Is it a true variant of an existing component? (Usually yes.)
  • If new: what's the threshold? (e.g., used in ≥ 3 places, by ≥ 2 product teams.)
  • Who owns it after launch? No owner = no addition.

Auditing an existing system

  1. Coverage — which UI surfaces use the system vs. one-offs? Map both.
  2. Token leakage — find raw hex / px values in product code. Each is a system gap or a system bug.
  3. Variant explosion — components with > 8 variants are usually 2 components disguised as one. Split.
  4. Dead components — used < 3 times, no owner. Deprecate.
  5. Docs gaps — components without "when to use / when not to use" sections.

Per-component documentation template

For every component the system owns:

## What it is
One sentence.

## When to use
- ...

## When NOT to use
- ... (often more important than the above)

## Anatomy
[diagram or labeled parts]

## Variants and props
[table]

## States
default · hover · focus · active · selected · disabled · loading · error

## Tokens consumed
[list]

## Accessibility
- Keyboard: ...
- Screen reader: ...
- ARIA: ...

## Do / Don't
Concrete examples, side by side.

## Code snippet
```jsx
<Component />

Changelog

  • v2.1 — added tone="warning" variant

See `references/08-ui-and-design-systems/design-systems.md` for the full template.

## Governance

- **One owner per component.** Owner reviews changes; owner is on the hook when it breaks.
- **A contribution path** that doesn't require permission for trivial additions but does for breaking changes.
- **Deprecation status** (active / deprecated / removed). Mark deprecated; communicate before removing.
- **Versioning** aligned with the code library; document breaking vs. additive.
- **Office hours** for product teams to ask questions — beats async-only.

## Output

When building or proposing:

Scope and approach

Token plan

Component list (priority order)

Open questions

Definition of done for v1


When auditing:

Strengths

Gaps

Risks

Recommended changes, prioritized

Effort estimates


## Common failures

- Designing the system perfectly; never maintaining it.
- Figma library and code library diverging silently.
- Adding a "snowflake" component for a single use case.
- Locking down contributions so tightly that product teams build outside the system to ship.
- A design system team that designs in isolation from product work.

## Hand-offs

- New visual decisions → `visual-language` skill.
- Designing a specific component → `ui-component` skill.
- Writing component docs → use the template here; `ux-writing` skill for the descriptions.

Keep looking

Skills are one crate of 608,475. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.