Skip to main content
skill CX Codex

scaffold-project — Claude Code skill: what it does, how to install

scaffold-project — a Claude Code skill that scaffolds a product design workspace with design tokens, rules, and folder structure. Runs when initiating a fresh design system or web application.

MIT ★ 3,216 updated 2026-11-10

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add plugin87/ux-ui-agent-skills
/plugin install ux-ui-agent-skills@ux-ui-agent-skills
Open on GitHub

What scaffold-project does

The skill copies the product design starter template into a designated target directory. It generates CLAUDE.md, CLAUDE.local.md, .mcp.json, design token files, and folders for UI components, reference screens, and assets.

Because disable-model-invocation is enabled, the model never executes this skill on its own; only the user can trigger it. It requires the parent kit [email protected] to be installed, as it aborts with a KIT_MISSING message if the tokens and templates directories are absent.

Render gates require [email protected] installed in dev dependencies, without which tests silently print SKIPPED. Python 3 runs the included contrast and layout validators. Credentials like FIGMA_API_KEY must live in shell environment variables rather than inside .mcp.json.

What it helps with

  • scaffold a design-driven project skeleton for Claude Code
  • set up initial design tokens with contrast validation
  • configure workspace rules for tokens and accessibility
  • prepare directory trees for components and reference screens

Example prompts for the agent

  • Scaffold a new project in directory my-app using scaffold-project
  • Create the design system layout inside ./dashboard
  • Initialize the workspace skeleton in client-portal

How to install scaffold-project

1Plugin marketplace

/plugin marketplace add plugin87/ux-ui-agent-skills
/plugin install ux-ui-agent-skills@ux-ui-agent-skills

This installs the whole ux-ui-agent-skills plugin with all its skills

2Skills CLI (Vercel)

npx skills add plugin87/ux-ui-agent-skills --skill scaffold-project -a claude-code

3Manually: put the files in place

~/.claude/skills/scaffold-project/SKILL.md

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

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

Questions about scaffold-project

How to install scaffold-project in Claude Code?

Add the marketplace and install the plugin using /plugin marketplace add plugin87/ux-ui-agent-skills followed by /plugin install ux-ui-agent-skills@ux-ui-agent-skills.

What does scaffold-project do?

It generates a standardized product design project layout containing CLAUDE.md, .mcp.json, .claude/rules/, and design-tokens.json.

What is required to run scaffold-project?

It requires the complete [email protected] suite, Python 3 for validation scripts, and [email protected] for render gates.

Source text

SKILL.md · MIT
---
name: scaffold-project
description: Scaffold a new design-product project that matches the recommended Claude Code layout (the reference structure). Use when starting a fresh product/app that will be built with this design system.
# A command the user runs. Converted from .claude/commands/ so it has a
# CLAUDE_SKILL_DIR of its own and its paths resolve on every install route.
# disable-model-invocation keeps the behaviour a command had: the user
# starts it, the model never does, and its description stays out of the
# listing budget the model's skill choice is drawn from.
disable-model-invocation: true
---
## Requirements

This skill needs the full UX/UI Agent Skills kit: the gates, the references and
the design-system library. Install it with `npx [email protected] init`
or as the Claude Code plugin. `npx [email protected] add` copies the skill folder and
nothing else, and this skill has no guidance-only mode: its whole job is to
copy the kit's starter template, so without the kit there is nothing for it to do.

> **Step 0: is the kit here?** Check once:
> `ls ${CLAUDE_SKILL_DIR}/../../../tokens >/dev/null 2>&1 && echo KIT_OK || echo KIT_MISSING`
> On `KIT_MISSING`, say plainly that only the skill folder was installed, name
> the install command above, and stop. Do not guess the contents of a file you
> could not open, and do not report a result you did not produce.

Generate a new design-project skeleton from `${CLAUDE_SKILL_DIR}/../../../templates/product-design/` into a target directory the user names.

The layout to produce (exactly the reference structure):

```
<target>/
  # CONTEXT CLAUDE LOADS
  CLAUDE.md              the brief Claude reads every session
  CLAUDE.local.md        your personal prefs, gitignored
  .mcp.json              Figma, Notion, Drive connections

  # TEAM TOOLKIT
  .claude/
    rules/               conventions, loaded only when relevant
    skills/              repeatable workflows, off main context
    commands/            your custom slash commands
    settings.json        shared permissions, checked into git

  # YOUR PROJECT
  design-tokens.json     source of truth: color, type, spacing
  src/components/        the real UI Claude reads and edits
  public/images/         real images so prototypes don't break
  reference/             real screens Claude studies for context
```

The fast path, when the kit is installed or reachable via npx:

```
npx [email protected] new <target>
```

That does steps 2 and 3 below in one call (template copied, `CLAUDE.local.md`
un-suffixed, engine areas installed without overwriting the lean brief). Then pick
up at step 4. The manual steps are spelled out so the same result can be produced
by hand from a clone.

Steps:
1. Ask for the target directory if not given. Create it if it does not exist.
2. Copy every file of `${CLAUDE_SKILL_DIR}/../../../templates/product-design/` into it, preserving the tree.
   Two rules on the copy:
   - `CLAUDE.local.md.template` lands as `CLAUDE.local.md` (the suffix exists
     only so the kit's own gitignore cannot swallow the file).
   - `.gitkeep` stays in `.claude/skills/`, `.claude/commands/`,
     `src/components/`, `public/images/`, and `reference/` so the empty folders
     survive the first commit.
   The template already ships `.gitignore` (which ignores `CLAUDE.local.md`),
   `.mcp.json`, `.claude/settings.json`, and three rules files
   (`components.md`, `tokens.md`, `accessibility.md`).
3. Install the engine next to it so the gates the brief references actually run:

   ```
   npx [email protected] add tokens components taste accessibility \
       workflows content frameworks design-systems scripts skills
   ```

   Use `add`, not `init`: `init` also writes the full engine `CLAUDE.md` over the
   lean project brief. The project brief stays short by design, and the engine
   knowledge loads from the copied folders when a task needs it.
4. Install the render gates' one dependency in the target: `npm i -D [email protected]`.
   Skipping this is silent: every render gate prints `SKIPPED` and exits 0.
5. Fill in the placeholders in `CLAUDE.md` with the user: product, primary user,
   stack, icon set, vocabulary. Leave nothing in angle brackets behind.
6. Point `design-tokens.json` at the brand: replace the `primitive.brand` ramp,
   keep the semantic and component tiers, then prove it still passes:

   ```
   python3 ${CLAUDE_SKILL_DIR}/../../../scripts/validate_contrast.py
   ```

7. Remind the user to fill `reference/` with real screens and `public/images/`
   with real imagery, and to set the MCP env vars (`FIGMA_API_KEY`, ...) in their
   own shell. Never write a secret into `.mcp.json`.

Verify before handing over: the target tree matches the layout above, and

```
python3 ${CLAUDE_SKILL_DIR}/../../../scripts/validate_template.py
```

passes against the source template.

© Thientan Soparat · MIT · plugin87/ux-ui-agent-skills

Similar skills

All skills for Frontend and UI →

From the same set35

The whole set →
gate Skill for Claude Code runs a UI quality gate before marking tasks complete. You trigger the command manually, preventing the model from calling it autonomously. CX Codex +1 ★ 3,216repo stars review-and-research review-and-research standardizes UI audits, usability checks, and design handoff requirements. Activates when Claude Code inspects screens or prepares components for developers. CX Codex +1 ★ 3,216repo stars brand-and-operations brand-and-operations is a Claude Code rule for brand consistency, motion, and UI copy. It loads when an agent sets an aesthetic direction, writes interface text, or works on system operations. CX Codex +1 ★ 3,216repo stars typography-and-spacing typography-and-spacing is a Claude Code rule for choosing type scales and layout spacing when an agent works on page typography or rhythm. It also covers checks for Thai text. CX Codex +1 ★ 3,216repo stars critique The critique Claude Code skill challenges a finished interface and finds grounds to reject it. Run it after the project gates pass. CX Codex +1 ★ 3,216repo stars design-critic design-critic — a subagent for Claude Code reviews rendered UI screens as an adversarial design director looking for reasons to reject the build. Runs after automated test gates pass. CX Codex ★ 3,216repo stars grill-me The grill-me Claude Code skill asks about a project before implementation and records unanswered decisions as assumptions. Run it before building an interface. CX Codex +1 ★ 3,216repo stars tokens-and-color tokens-and-color is a Claude Code rule for creating, extending, or auditing tokens and choosing interface colors. It defines token layers and contrast requirements. CX Codex +1 ★ 3,216repo stars

Project sponsors

Companies that keep this analytics open