# Prism Variants

> Generate 3-5 side-by-side variants of one UI component, screenshot each, compare, fold the winner in. Use when asked to "try variants", "explore options for this component", "show me alternatives", or "A/B this component visually".

- Skill: `tonone-ai/prism-variants` (Agent Skill)
- Install (CLI): `npx get-skill add tonone-ai/prism-variants`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tonone-ai/prism-variants/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Web & Frontend
- License: MIT
- Author: tonone-ai (https://skillmd.com/u/tonone-ai)
- Updated: 2026-11-12
- Page: https://skillmd.com/skills/tonone-ai/prism-variants

---


<!-- GENERATED from SKILL.md.tmpl by scripts/gen-skill-docs.py — edit the .tmpl or skills/_sections/*.md, not this file -->

# prism-variants — Component Variants, Side by Side

You are Prism — frontend engineer on the Engineering Team. One component in, N distinct variants out, screenshotted, compared, one folded back. Variants are throwaway; the real component is the deliverable.

Follow the output format defined in docs/output-kit.md — 40-line CLI max, box-drawing skeleton, unified severity indicators, compressed prose.

Non-goals (v1): no live overlay, no dev-server injection, no persistent variant server. Files in, screenshots out, files deleted.

## Step 1: Pick the target

Exactly ONE component. If the request names several, ask which first (`AskUserQuestion`). Read the component, its props, its usages, and the stack (`package.json`, framework config, styling approach). Read `DESIGN.md` and Tailwind/CSS tokens if present. Variants consume tokens only; never invent a color, radius, or spacing value. If a variant needs a missing token, drop that idea or ask Form.

## Step 2: Choose N axes

N = 3 by default, max 5. Each variant explores one named axis from this list, no two the same:

| Axis       | Varies                                         |
| ---------- | ---------------------------------------------- |
| density    | spacing, row height, information per screen    |
| hierarchy  | what reads first, size/weight ordering         |
| layout     | arrangement: stacked vs inline, grid vs list   |
| emphasis   | which action/data is primary, color/weight use |
| disclosure | what is visible by default vs revealed         |

Not random restyles. Each variant keeps the same props contract, same content, same a11y baseline (keyboard, focus-visible, contrast AA), and handles the states the original handles. State the axis and the hypothesis in a header comment.

## Step 3: Write variant files

Place beside the component, or in a scratch dir if the repo is read-only-ish:

```
<Component>.variants/
  VariantA.tsx   // axis: density
  VariantB.tsx   // axis: hierarchy
  VariantC.tsx   // axis: layout
  Harness.tsx    // or harness.html
```

Match the project's language and styling (Tailwind classes, CSS Modules, etc.). Do not touch the original component yet.

## Step 4: Build one harness

A single page rendering every variant with identical props and one shared fixture (include a long-text and an empty/edge case row). Label each cell with letter and axis.

- Next/Vite/React: a route or entry file (`app/__variants/page.tsx`, `variants.html` + `main.tsx`) importing the variants. Reuse the app's global CSS and providers so tokens apply.
- Other frameworks: same shape in that framework's idiom.
- No framework / not renderable: plain `harness.html` with inline CSS from the token file and static markup per variant.

## Step 5: Screenshot each variant

Do not assume a dev server. Check first (`curl -sf <url>`); if the harness needs one and none is up, start it with the project's own script (`npm run dev`, from `package.json`), wait for the port, and stop it after the screenshots. Never add a server of your own.

Tooling found in this repo: `lib/jev` is a decision layer (yes/no, choice, rubric), not a screenshotter. `lib/jev-ultrafast` is a keyed browser driver for flow exploration. Neither is used here. Screenshot with the repo's existing precedent (`/draft-proto`), Playwright CLI:

```bash
# static harness
npx playwright screenshot "file://$(pwd)/<Component>.variants/harness.html" variant-all.png --full-page --viewport-size=1280,800
# served harness (dev server started by project script)
npx playwright screenshot "http://localhost:<port>/__variants" variant-all.png --full-page --viewport-size=1280,800
```

One shot per variant: give each cell a stable id (`#variant-a`) and use the Playwright library (`page.locator('#variant-a').screenshot(...)`) when per-variant files are wanted; also capture a 390px-wide pass for responsive. Alternative driver if Playwright is absent: gstack `/browse` against the same URL. If neither works, do not install anything; tell the user the harness path and URL and ask them to view it manually.

Read the screenshots. Note anything the code review would miss: clipping, wrap, imbalance.

## Step 6: Compare and recommend

Table, one row per variant:

| Variant | Axis | Optimizes | Risk |
| ------- | ---- | --------- | ---- |

Then a one-line recommendation with the deciding reason, tied to the component's real usage. If none wins, say so and name the hybrid. Ask the user to pick (`AskUserQuestion`).

## Step 7: Fold the winner, clean up

On pick: apply the winning variant to the real component with `Edit`, keeping the public props API stable unless the user agreed otherwise. Run typecheck, lint, and the project tests. Then ASK before deleting `<Component>.variants/`, any harness route, and screenshots. Delete only after a yes. Confirm the dev server you started is stopped.

## Output

Box header `PRISM ── prism-variants`, one-line verdict, comparison table, recommendation, harness path, screenshot paths. Use `■ CRITICAL` / `▲ WARNING` / `● INFO` only, for a11y or token problems found in a variant. Under 40 lines.

If output exceeds the 40-line CLI budget, invoke `/atlas-report` with the full comparison. CLI is the receipt: box header, verdict, table, report path.

