Three nested concentric shells with an open pocket in the outer one, a milled insert with two dowel pins hanging from a gantry arm just above it, the front of the shells ghosted in bone-grey line, and an indigo line running down the gantry and through the insert into the pocket.
Creative

Webdesign

Designs and integrates web interfaces via DirectDesign (inline, Anthropic frontend-design philosophy, the default) or NativeDesign (/design artboards plus /design-sync design-system sync)

02
Workflows
01
Tool
02
References
16
Triggers

The Problem

Generic AI design help means generating HTML with inline styles that look like a default Bootstrap site from 2014, or describing what a design should look like and leaving you to build it. The model has no access to claude.ai/design, no awareness of your existing codebase tokens, and no way to produce output that integrates as a diff into a real app. You either get greenfield code that fights your existing system or a screenshot-level mockup with no path to production.

How This Skill Approaches It

Two real paths, picked explicitly by the situation. DirectDesign loads the Anthropic frontend-design philosophy from FrontendDesignPhilosophy.md — register list, anti-default rules, type pair recipes, motion vocabulary, color discipline — and writes the design inline against your actual codebase without any round-trip to an external tool. ClaudeDesign drives claude.ai/design (Claude Opus 4.7 vision) programmatically through Interceptor, the real-Chrome automation layer, to get visual-first prototypes when stakeholders need to review before code lands. After a prototype ships, IntegrateIntoApp audits the target project's framework, runs ExtractDesignSystem to prime Claude Design with your real tokens, then produces a unified diff against the working tree — not an overwrite. VerifyDesign.ts runs a screenshot and accessibility probe before anything goes to production.

Not for illustrations/logos (Art), video (HyperFrames)

In Action

What you say to your DA, and what the Webdesign skill actually does.

  • You say "design a pricing page for my ai security startup, dark only, editorial feel"
    Routes to CreatePrototype: composes a brief with the explicit aesthetic and constraints, drives claude.ai/design via DriveClaudeDesign.ts through Interceptor, screenshots the output, runs VerifyDesign.ts for accessibility, and returns the bundle path with a preview.
  • You say "make this component look good, just do it yourself"
    Routes to DirectDesign: loads FrontendDesignPhilosophy.md inline and writes the design directly against the existing codebase — no claude.ai round-trip — producing a diff that respects your existing tokens and component patterns.
  • You say "take this prototype and land it in my astro site"
    Routes to IntegrateIntoApp: audits the target project's framework and design tokens, runs ExtractDesignSystem first so Claude Design uses your real system, translates the prototype to Astro conventions, produces a unified diff for review, then applies on confirmation.

Inside the Skill

The thinking, frameworks, and architecture that distinguish this skill from a generic version of the same task.

Ideal State

  • Every design lands as working code (or a picked artboard implemented) in the host app's framework, diffed against its existing tokens and components; a full redesign happens only when the user asked for one, and replacing existing UI otherwise is flagged and confirmed first.
  • The result looks made for its subject and its host app, never like a generic AI page: a named register, none of the forbidden defaults in References/FrontendDesignPhilosophy.md.
  • The path fits the ask: DirectDesign for in-code work, NativeDesign for comparing looks or design-system sync, and an ambiguous ask gets both paths offered by name, never routed silently.
  • Nothing reaches the principal as a first draft (principal directive, 2026-09-17): before it is shown, the rendered result has an Interceptor capture and an ArtDirection critique that passed the bar, or a reported shortfall.

Intent Routing

Intent Trigger File
DirectDesign (default, bundle direct) in-code UI design or a self-contained page; short ad-hoc design asks, "make a nice design", "do the design yourself", frontend aesthetics, brutalist/editorial/retro/maximalist UI Intents/DirectDesign.md
NativeDesign (bundle native) artboards, "show me variants", "give me a few directions", "pick a design", mockup, prototype, "claude design", /design, /design-sync, design-system sync Intents/NativeDesign.md

DirectDesign fits one pass that lands as code in an existing codebase or as a self-contained page, including when claude.ai access is unavailable. NativeDesign fits when the principal should compare genuinely divergent looks side by side, review visually before implementation, or the job is design-system sync. Illustrations and logos go to Art: brand assets are authored SVG, never generated UI output.

Uncertain routing or the full reference loads bundle full. The direct bundle includes the full aesthetic reference and the DirectDesign intent, so its doctrine read is already satisfied; do not fetch the same bytes again. NativeDesign retains its original prerequisites and approvals.

File Read when
References/CompleteGuide.md the loader fails, or the full bundle: integration-aware operation, preflight, the dated gotchas
References/FrontendDesignPhilosophy.md any DirectDesign run or NativeDesign brief: the aesthetic doctrine, registers, type pairs, forbidden defaults
References/InputFormats.md writing a design brief, importing a design system, choosing iterate vs restart
References/ClaudeDesignCapabilities.md what Claude Design and /design can and cannot do, access, known limits
References/SiteLaunch.md public-site builds and launch completion
README.md the public-facing intro to the skill
Setup.md first-time setup: Interceptor test context for the rendered check, and Claude Design access for NativeDesign

Tool contract

Load context with the deterministic loader before executing an intent: bun "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/LIFEOS/TOOLS/ContextLoad.ts" Webdesign load BUNDLE

It returns the selected instructions and their required sections with source hashes; follow every returned requirement. Use list to discover sections and bundles, and search "query" to search the indexed source; a failed search does not establish absence, so broaden it or load full. If the loader fails, read References/CompleteGuide.md and the relevant intent directly. Do not proceed with a partial load.

Verification and the quality loop:

  • Browser evidence uses Interceptor's verify bundle, including all its isolation and safety requirements. An unavailable verifier leaves the result explicitly unverified.
  • Capture the rendered page with Tools/VerifyDesign.ts or skills/Interceptor/Tools/Capture.sh.
  • Skill("ArtDirection") runs a direction council before new or large work; then the cross-vendor critique panel (skills/ArtDirection/Tools/Critique.ts) scores the capture against the rubric and names defects, and this skill iterates on those defects until the bar or reports the shortfall.
  • A file handed over through Downloads goes through skills/ArtDirection/Tools/Deliver.ts, which refuses without a passing, fresh critique and a Proof receipt.
  • Record the principal's verdict with skills/ArtDirection/Tools/Calibrate.ts.
  • Public-site builds and launch completion also load References/SiteLaunch.md; component edits and standalone mockups do not require registration.

Data & Config

First-time setup (accounts, keys, files to fill in): Setup.md.

User design preferences (color palette, typography, spacing grid, animation timing, framework defaults, the last shipped sites) live at <configRoot>/LIFEOS/USER/CUSTOMIZATIONS/SKILLS/Webdesign/PREFERENCES.md (configRoot is $CLAUDE_CONFIG_DIR when set, else ~/.claude). When present they feed every brief, DirectDesign inline, or the NativeDesign artboard brief and design-system project, and bias the register choice without binding it. Never substitute generic defaults for configured preferences. Without preferences, choose freshly each session and rotate registers across runs.

Examples

User: "Redesign the Example App page /app/reports/weekly inside the existing app shell — it looks like trash"
→ DirectDesign, framework-matched-diff
→ The page uses the app's own components and tokens, reads as designed rather than a plain table, and ships with its screenshot and a passing critique
User: "Design and build example.com, a public content site for the course. Deploy only after I look."
→ DirectDesign plus References/SiteLaunch.md
→ A rendered site with a committed register, launch criteria in the project ISA, and the deploy held for the principal's yes
User: "Pull this repo's design system into Claude Design"
→ NativeDesign, sync leg
→ The design-system project holds the repo's real tokens and components, so later artboards start from the brand

Workflows & Routing · 2

Each workflow is one job the skill runs. The trigger phrases route your request to the right one — this is the skill's routing table.

  1. 01
    DirectDesign (default, bundle `direct`) Intents/DirectDesign.md

    in-code UI design or a self-contained page; short ad-hoc design asks, make a nice design, do the design yourself, frontend aesthetics, brutalist/editorial/retro/maximalist UI

  2. 02
    NativeDesign (bundle `native`) Intents/NativeDesign.md

    artboards, show me variants, give me a few directions, pick a design, mockup, prototype, claude design, /design, /design-sync, design-system sync

Tools · 1

Deterministic executables the workflows call — the code that does the real work, not prompt scaffolding.

  • VerifyDesign.ts

How to Invoke

Say any of these to your DA and LifeOS activates the Webdesign skill automatically:

  • "web design"
  • "UI design"
  • "artboards"
  • "design variants"
  • "create prototype"
  • "design system"
  • "design sync"
  • "redesign site"
  • "mockup"
  • "landing page"
  • "dashboard design"
  • "design-to-code"
  • "frontend design"
  • "polish UI"

Or invoke explicitly:

Skill("Webdesign")

References · 2

Auxiliary files the skill loads at runtime — frameworks, guides, configs.

  • README
  • Setup

References & Credits

The thinkers, books, frameworks, and research this skill is built on. The ideas belong to them — the integration belongs to LifeOS.

Want LifeOS to do this for you?

Install LifeOS on your machine — your DA gets the Webdesign skill plus 96 others, all hooked into one Life OS.