Skip to main content
skill CX Codex

frontend-design · paulrberg — Claude Code skill: what it does, how to install

frontend-design — a skill for Claude Code, Codex and Cursor that builds web interfaces with custom art direction and verifies them in the rendered UI.

MIT 111 installs ★ 107 updated 2026-10-24

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add PaulRBerg/agent-skills --skill frontend-design -a claude-code
Open on GitHub

What frontend-design does

The skill builds web pages and redesigns existing interfaces while preserving the underlying framework and design system. It detects system appearance to set color tokens and establishes hierarchy before writing code. Visual verification runs through a browser tool or devtools.

Before generating code, the skill inspects neighboring components, typography, and repository assets. On macOS, it executes defaults read -g AppleInterfaceStyle to check system appearance modes.

The skill relies on the chromium-browser dependency for rendered checks. It preserves existing responsiveness and avoids replacing user stacks without a direct request.

What it helps with

  • build a web interface from scratch
  • redesign a dashboard keeping the tech stack
  • verify layout quality in a rendered browser view
  • inspect a component and propose art direction

Example prompts for the agent

  • Build a dashboard interface using frontend-design
  • Redesign the landing page while keeping the current framework
  • Critique the current UI and report visual direction without editing files

How to install frontend-design

1Skills CLI (Vercel)

npx skills add PaulRBerg/agent-skills --skill frontend-design -a claude-code

2Manually: put the files in place

~/.claude/skills/frontend-design/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/frontend-design/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about frontend-design

How to install frontend-design in Claude Code?

Run npx skills add PaulRBerg/agent-skills --skill frontend-design -a claude-code in your terminal, then point to ~/.claude/skills/frontend-design/SKILL.md.

What does frontend-design do?

The skill creates working web interfaces with specific visual direction and verifies the result in a rendered browser. It configures color palettes and layouts without altering your core stack.

What is needed to run frontend-design?

The skill depends on chromium-browser for rendered visual verification.

Source text

SKILL.md · MIT
---
compatibility:
  Designed for Codex and Claude Code. Prefer the chromium-browser skill for rendered verification when available,
  otherwise the host's DevTools/browser tool.
name: frontend-design
skill-dependencies:
  - chromium-browser
description:
  Use when creating or substantially redesigning web interfaces, landing pages, dashboards, components, or other
  frontend UI where visual direction and implementation quality matter. Produces subject-specific art direction,
  accessible code, and rendered visual verification.
---

# Frontend Design

Create a working frontend with a clear, subject-specific point of view. Then prove it in the rendered UI.

## Contract

- For a critique, review, or design plan, inspect the relevant product and report the direction without editing files.
- For a build or redesign, make the requested in-scope changes and run local, non-destructive validation.
- Treat explicit user direction, supplied references, repository instructions, existing product behavior, and the local
  design system as authoritative. Fidelity requests override this skill's defaults.
- Preserve the stack and working behavior. Do not replace the framework or design system, add dependencies, or invent
  features unless the request requires it.
- Preserve distinctive existing artwork and useful visual cues during redesigns. Before replacing them, verify that the
  replacement retains their contribution to identity, comprehension, or interaction.
- Choose original SVG authored in code or stock imagery when it supports the art direction. Generate other media only
  when the request requires it.
- Make the smallest defensible assumption when the subject, audience, or page job is missing. State it before building.
  Ask only when the answer would materially change scope or identity.

## Layout and Theme Defaults

Treat every build as a one-off page for a specific purpose. Apply these defaults unless the user specifies otherwise:

- Build for a desktop browser window only. Do not add a mobile or responsive layout.
- Build one theme only. Do not add a second theme, a theme toggle, or a `prefers-color-scheme` variant.
- Before you choose colors, detect the system appearance. Use a light theme only when the system uses light mode.
  Otherwise, use a dark theme.
- On macOS, run `defaults read -g AppleInterfaceStyle`. It prints `Dark` in dark mode. In light mode, it fails because
  the key does not exist.

When you change an existing surface, keep its working responsive and theme behavior. Do not extend it to new work unless
the user asks.

## Workflow

### 1. Read the product before drawing the page

Inspect the affected route or component, neighboring UI, tokens, typography, assets, dependencies, and repository
validation commands. Identify:

- the concrete subject and audience.
- the screen's single primary job and content hierarchy.
- the existing visual language and interaction conventions.
- the required viewports, themes, states, and accessibility constraints.

Use real product content and supplied assets wherever possible. If copy is missing, write only what the user needs to
understand the interface and act.

### 2. Set one art direction

Before coding, define a compact direction:

- **Thesis:** one sentence connecting the visual idea to the subject and screen job.
- **System:** role-based color tokens, explicit type roles and scale, spacing and density, and deliberate layout and
  alignment choices.
- **Signature:** one memorable element drawn from the domain's objects, workflows, data shapes, environments, or
  language.
- **Risk:** one deliberate departure from the obvious solution, with a reason it serves this brief.
- **Motion and copy:** when motion helps, how the interface speaks, and where restraint matters.

Adapt this direction to existing brand constraints instead of creating a parallel design language. Keep options and
process narration internal unless the user asked to choose among directions.

For builds and substantial redesigns, evaluate imagery case by case. Consider stock photos, artwork, or original SVG for
backgrounds, section transitions, or focal details. Use images only when they strengthen the site's subject, atmosphere,
or content hierarchy. An image-free design is valid. Read [SVG design](references/svg-design.md) when choosing or
building an original SVG motif.

When stock imagery suits the direction, use `$chromium-browser` to search Google or [Unsplash](https://unsplash.com/).
Open the original source to verify usage rights and any attribution requirements before using an image. Search results
alone do not establish permission to reuse an asset.

Compose imagery and colorful backgrounds as one palette. Choose complementary colors, deliberate crops, and quiet space
behind text and controls. Avoid generic stock images that could fit any unrelated site.

### 3. Run the anti-default critique

Apply the **subject-swap test**: mentally replace the subject with an unrelated one. Any major choice that still works
unchanged is probably a template default. Revise that choice or justify why it is structurally correct.

Make every visual device earn its place. Cards, pills, gradients, numbering, dividers, oversized type, split heroes,
illustrations, and animation must communicate hierarchy, function, sequence, or subject—not merely decorate. Concentrate
expressive force in the signature and make the surrounding system support it.

Clear delineation is a functional requirement. Borders and containers are valid when they make grouping and ownership
easier to scan. Do not remove useful boundaries merely to make a design flatter or less conventional.

Use concrete patterns as critique prompts, not absolute bans. Question cream backgrounds, italic headline accents,
`01/02/03` section labels, monospace labels, and pill-shaped buttons when the brief does not support them. Apply the
same test to repeated decorative cards, shadows, and section entrance effects. Preserve these choices when they serve
the brief or a clear function. After the first render, identify other unexamined defaults and revise them.

### 4. Build the actual experience

- Follow local components, tokens, styling architecture, and dependency versions before introducing new primitives.
- Match composition to use: operational tools favor scannable information and efficient repeated actions. Editorial or
  marketing surfaces may use a more expressive narrative.
- Make the first viewport establish both identity and primary purpose. For an application or tool, show the real working
  experience rather than wrapping it in an unrequested landing page.
- Make projects, records, and independent panels easy to distinguish with visible borders, surface contrast, and
  spacing. Preserve useful group borders unless a rendered replacement makes the boundaries at least as clear.
- Use cards for related or repeated objects. Use nested containers only when they communicate a real hierarchy.
- Give typography deliberate display, body, and utility roles. Use available fonts first. Do not add a font dependency
  solely for novelty. One or two font families can provide these roles.
- Keep body text readable, usually below 80 characters per line. Adjust the measure and line height to the typeface and
  content.
- Write interface copy from the user's side: specific nouns, active verbs, consistent action names, sentence case, and
  useful empty and error states. A control's label must describe its result.
- Use familiar controls and the project's icon library. Give unfamiliar icon-only controls accessible names and visible
  tooltips where appropriate.
- Motion is optional. When using it, concentrate it where it explains hierarchy or gives useful interaction feedback.
  Respect reduced-motion preferences and ensure the experience remains clear without animation.
- Tune motion for perceived speed. Use ease-out curves instead of ease-in for feedback to user input, so the change
  starts at full speed and settles. Keep most interface animations under 300 ms. When an interaction must feel snappy,
  use a custom `cubic-bezier()` curve instead of the browser's `ease` keyword. Make loading spinners rotate quickly. A
  slow spinner makes the same wait feel longer.
- Prevent overlap, clipping, unreadable wrapping, and layout shift at every width in scope. By default, the scope is one
  desktop width. When the user requests responsive behavior, build responsive constraints from content rather than
  device labels, and include narrow and wide widths.
- For images, choose responsive crops and delivery sizes that preserve the focal point without unnecessary download
  weight. Give meaningful images useful alt text and decorative images empty alt text.
- Preserve semantic structure, keyboard operation, visible focus, adequate contrast, and target sizes. Match the
  project's accessibility standard when it is stricter.
- Keep selector specificity and component ownership predictable. Do not rely on competing selectors or fragile cascade
  order to establish spacing and state.

### 5. Render, inspect, and revise

Run repository-required checks and the narrowest additional checks that prove the changed behavior. Select among
formatting, lint, typecheck, tests, and build according to the affected surface. Reuse passing evidence until edits or
unresolved concerns invalidate it. Then do rendered verification with the chromium-browser skill when it is available in
this session. Otherwise, use the host's DevTools/browser tool. Do not fall back to Computer Use or ad-hoc Playwright
scripts while a DevTools browser tool is available.

Scale the inspection matrix to the change. Repository instructions may reduce the viewport/state matrix, including
waiving multi-viewport checks. Follow those instructions. Absent such instructions, a small edit to existing UI needs
verification only of the changed states at one representative viewport. A new or substantially redesigned surface needs
one desktop viewport in its single theme and every changed interaction and state. When the user requests responsive
behavior or several themes, add representative narrow and wide viewports and each requested theme. Behavior belongs in
the repository's automated tests where they exist. Use the browser for visual, layout, and theme questions.

Check the rendered result for content hierarchy, group boundaries, subject specificity, asset loading, overflow,
overlap, truncation, contrast, focus, hover, motion, empty/error states, and theme variants in scope. Confirm that each
item's group and each group's extent remain obvious at the tested widths and in each theme. Compare the result with the
brief and the art direction. Fix visible defects and remove any element that does not materially serve either.

Do not claim visual verification from source inspection alone when rendering is available. If the environment cannot
render the UI, state that limitation and report exactly what was verified instead.

## Completion

Completion requires the requested artifact or code, a subject-specific direction reflected in the implementation,
passing relevant local checks, and rendered inspection evidence when tooling permits. Report the direction in one
sentence, the checks and viewports exercised, and any remaining limitation.

Finish builds with `### ✨ Built: <surface>`, `🎨 Direction — <one sentence>`, and `### 🧪 Verification`. When several
states were inspected, use a compact viewport/state/result table. When screenshots or artifacts are available, link
them. Add `### ⚠️ Remaining` only when non-empty. Agent-report decoration does not authorize emoji or ASCII ornament in
shipped interface copy, snapshots, or source unless the brief or design system calls for it.

© PaulRBerg · MIT · PaulRBerg/agent-skills

Similar skills

All skills for Frontend and UI →

frontend-design by other authors comes first.

frontend-design official anthropics The frontend-design skill guides intentional visual design for new interfaces and redesigns. Use it when a generic generated UI is not enough. CX Codex +1 1,025,790installs frontend-design cline The frontend-design skill makes the agent pick a bold visual direction before writing code, then hold it through every detail. Useful when a generated interface should not look generated. CX Codex +1 9,000installs frontend-design sickn33 frontend-design teaches the agent to create memorable interfaces instead of generic layouts: picks an aesthetic direction, checks accessibility, writes clean code. CX Codex +1 2,700installs frontend-design julianoczkowski frontend-design generates production-grade UI based on established design philosophies. It checks existing tokens and components before writing any new code. CX Codex +1 5,700installs frontend-design Ilm-Alan frontend-design — a Claude Code skill that holds a visual direction for frontends through palette, typography, structure, and texture. It runs when you build or restyle an interface and need a specific style, not a vague sense of polish. CX Codex +1 647installs product-frontend-design mosif16 product-frontend-design — a skill for designing and fixing SaaS landing pages and product interfaces: clarifies hierarchy, removes jargon, delivers distinctive visual style. CX Codex +1 271installs ns-frontend-design nextstage-brasil ns-frontend-design — a skill for Claude Code, Codex, Cursor and other agents that builds production UI with deliberate typography, hierarchy and motion. Activates on pages, components, dashboards, forms and analytics views. CX Codex +1 153installs frontend-design-skills fcakyon Adds frontend design, interaction testing, and UI copy capabilities to Claude Code. Useful when you need a designer, QA tester, and copywriter in one chat. CX Codex ★ 1,216repo stars designing-frontend-interfaces osmontero The designing-frontend-interfaces skill makes the agent write a design brief and lock a token block before touching component code. Useful when your UI looks like default AI output. CX Codex +1 783installs frontend-enhancer travisjneuman frontend-enhancer polishes the visual side of a web app: palette, layout, motion, component states. Useful when the UI still reads as a stock starter. CX Codex +1 145installs frontend-blueprint Felipe Rodrigues - github.com/felipfr frontend-blueprint turns Claude into a design consultant: brief, references and an agreed direction come first, code after. CX Codex +1 ★ 7,191repo stars

From the same set16

The whole set →
cli-cast cli-cast — a Foundry Cast skill for preparing, simulating, signing, and broadcasting transactions. It also handles ABI data and message signatures. CX Codex +1 309installs spreadsheets spreadsheets — a skill for CSV, TSV and .xlsx files: it inspects structure, edits only the rows you ask for and recalculates formulas. Use it when the table is the main input or output. CX Codex +1 267installs vitest Testing instructions for coding agents writing, running, and debugging Vitest suites in TypeScript projects. CX Codex +1 186installs evm-atlas evm-atlas is a Claude Code skill that researches EVM chains, wallets, transactions, bridges, and historical DEX activity, providing read-only evidence without broadcasting transactions. CX Codex +1 153installs todo-archive todo-archive moves completed .ai/TODO.md tasks into dated daily archive files. Unchecked items stay untouched. CX Codex +1 130installs agents-introspection The agents-introspection skill reviews local Codex and Claude Code transcripts to spot recurring agent behavior and suggest a focused durable fix. CX Codex +1 123installs node-deps-bumper node-deps-bumper — a skill for Claude Code and Codex that structures package upgrades via Taze and guards against regressions. Runs whenever npm, pnpm, yarn, or bun dependencies need updates or dry-run checks. CX Codex +1 106installs release-bumper release-bumper — a skill for Claude Code that automates package releases. It calculates semver bumps, compiles changelog entries, commits changes, and creates annotated tags. CX Codex +1 105installs

Project sponsors

Companies that keep this analytics open