The studio is now a terminal.

Paul Bakaus — formerly Chrome DevTools, before that jQuery UI — built Impeccable as an honest upgrade to Anthropic's official frontend-design skill. It hit 10k stars in four months and reached v3.1.1 in May 2026. The thesis is simple: AI coding assistants have no design vocabulary, and asking one to "make this look better" produces the same Inter-purple-gradient-nested-cards output every time. Impeccable gives the model a vocabulary — 23 commands, accessed as /impeccable polish, /impeccable critique, /impeccable distill, /impeccable bolder, /impeccable quieter, /impeccable overdrive.

The split that earns the slot: every task is either brand (marketing, landing page, portfolio — design is the product) or product (dashboard, admin, settings panel — design serves the product). Brand defaults to display fonts, drenched color, orchestrated motion. Product defaults to system fonts, restrained palette, 150–250ms transitions, predictable grids. Same skill, opposite registers. Most generic skills pretend this distinction doesn't exist and ship dashboards that look like landing pages.

"The same 'save' button looks different in two places — one of them is wrong."

Beyond the LLM register, Impeccable ships 27 deterministic anti-pattern rules running through a standalone CLI (npx impeccable detect) — no API key, no token spend. Catches side-tab borders, purple gradients, bounce easing, dark glows, cramped padding, skipped headings, small touch targets, line length violations. The browser extension does the same against any live URL. This is the cheap-and-fast lint pass before the expensive critique pass.

For swarm.ing specifically: install at the user level (~/.agents/skills/), share via Dropbox symlink to ~/Dropbox/obsidian/claude/config/, run /impeccable teach once to seed DESIGN.md and PRODUCT.md at the repo root. Then /impeccable craft for new features, /impeccable critique before shipping, npx impeccable detect in CI.

Built by 花叔 (Alchain) — a Chinese indie dev with 300k+ followers, author of Cat Light (App Store paid #1) — Huashu reached 13k stars within weeks of release and is positioned opposite to Claude Design: where Claude Design is GUI-in-browser, Huashu lives entirely in your terminal. The output is HTML, but the deliverables are everything else: clickable iPhone prototypes (Playwright-verified), HTML slide decks (with editable PPTX export via html2pptx.js), MP4 motion graphics (25fps → 60fps interpolated + BGM + SFX), infographics (PDF/SVG print-quality), and a 5-dimensional expert critique.

The trick that makes it interesting: when a user brief is vague ("make me a good-looking page"), Huashu doesn't guess. It enters Design Direction Advisor mode and picks 3 different directions from its library of 20 design philosophies — Pentagram's information architecture, Field.io's motion poetics, Kenya Hara's eastern minimalism, Sagmeister's experimental work, plus 16 more — each from a different school (Swiss/International, Japanese minimalism, Italian maximalism, Memphis/postmodern, brutalism), generates 3 demos in parallel, and asks you to choose. This is the Junior Designer protocol, and it's the single biggest reason output stops feeling like AI freestyle.

"Claude Design is a better graphics tool. Huashu makes the graphics-tool layer disappear. Two paths, different audiences."

The motion pipeline alone is worth the install: scripts/render-video.js records HTML at 25fps via Playwright, scripts/convert-formats.sh ffmpeg-interpolates to 60fps + palette-optimized GIF, scripts/add-music.sh drops in scene-matched BGM (tech/ad/educational/tutorial) plus SFX. Claude Design cannot generate MP4. If you ship motion graphics — for Openclaw's arena dashboard, for swarm.ing's marketing, for anything that benefits from your existing Rive + Lottielab pipeline — Huashu is non-optional.

License caveat that matters: personal use is free (learning, research, side projects, content). Commercial use requires explicit written permission from the author. This was confirmed in multiple sources as recently as April 21, 2026 — earlier reports of MIT licensing appear to be wrong or premature. For swarm.ing's commercial work, negotiate a license, or use Impeccable for production and Huashu for prototypes/internal/marketing/research.

You have this one already (visible in /mnt/skills/user/ui-ux-pro-max/SKILL.md). 71k+ stars on the wondelai/skills repo — the largest community design skill by adoption. Pro Max takes the opposite philosophical bet to Impeccable: variety over discipline. Pick from 67 named styles (glassmorphism, claymorphism, brutalism, neumorphism, bento grid, skeuomorphism, flat design, etc.), 96 palettes, 57 font pairings, 25 chart types, 13 implementation stacks (React, Next.js, Vue, Svelte, SwiftUI, React Native, Flutter, Tailwind, shadcn/ui).

This is the skill you reach for when the brief is "design me three variants and let me pick" — its strength is breadth and exploration speed. Where Impeccable says "commit to a direction, here's the rule for that direction," Pro Max says "here are five directions you might not have considered, here's a working draft of each." Complementary, not competitive.

Practical pairing: use Pro Max for the first divergent pass (3–5 variants, different styles/palettes), pick a direction, then hand off to Impeccable's /impeccable polish + /impeccable audit for the convergent refinement. Pro Max's exploration; Impeccable's discipline. Both already installed, both running off the same Claude Code skill loader.

Anthropic's official skill (visible in your environment at /mnt/skills/public/frontend-design/SKILL.md) defined the genre when it shipped — the first widely-distributed skill that explicitly fought "AI-generated aesthetics like overused font families (Inter, Roboto, Arial), cliched color schemes (particularly purple gradients on white backgrounds), predictable layouts." 277k+ installs as of March 2026. It's the foundation Impeccable was built on.

The original instruction set still pushes the model toward bold aesthetic commitment, distinctive typography, and execution complexity that matches the aesthetic vision (maximalist designs get elaborate code; minimalist designs get restraint). The principles are right. The execution is sparse — about 250 lines, vs. Impeccable's seven domain reference files and 27 detector rules.

You can install both. They don't conflict — Impeccable explicitly builds on frontend-design's vocabulary. But for daily work, prefer Impeccable's commands. Keep frontend-design as the floor.

If the agent loop ever stops being enough — if you need to see the layout because words can't describe what's wrong — Pencil is the canvas to reach for. The thesis: design files are code artifacts; they belong in git, not in a separate proprietary cloud. Pencil's .pen file format is plain JSON describing an object tree, version-controlled exactly like your code. Branch your code → branch your design. Roll back a feature → the UI rolls back with it.

The interface stunt that's actually useful: when you give Pencil a task, it spawns up to six agents in parallel, each with its own cursor visible on the canvas. One master agent directs, others coordinate, divide work, execute simultaneously. You watch a typography agent set tokens while a hero-layout agent generates variants while a third propagates components across screens. Sequential output replaced by a team working in parallel.

"It feels less like using a tool and more like watching a team of designers collaborate in real time."

The reason this earns the canvas slot — and why Paper.design doesn't — is the real CLI. pencil --out login.pen --prompt "..." runs the AI agent headlessly, no GUI required. Interactive shell (pencil interactive) lets you call MCP tools directly on .pen files. Batch-process designs. Export to PNG/JPEG/WEBP/PDF from the terminal. This matches your CLI-over-MCP principle. Authentication via ~/.pencil/session-cli.json or PENCIL_CLI_KEY env var.

Honest gap: alignment can drift 4–8px on complex three-column responsive layouts; you fix it manually. Output quality varies between agents. The walkthrough file matters — don't skip it.

Paper takes the same "code is the artifact" bet as Pencil, but goes one level deeper: the canvas itself speaks real HTML and CSS. Every artboard you create is already a step closer to shipping. The layout engine understands padding, gap, flex direction. There's no translation layer, no export step that breaks your spacing. This is philosophically the most ambitious tool in the field.

The MCP integration is the genuinely new thing: Paper exposes 24 tools through an authenticated MCP server, with bidirectional access (read + write). An agent in Claude Code can inspect your design and mutate it — create_artboard, write_html, set_text_content, update_styles, rename_layer, duplicate_node, delete_node, plus reads like get_selection, get_jsx, get_screenshot, get_computed_styles. Pull content from Notion, Figma, or any API directly into the design. Sync tokens both ways.

"What if the design was the code from the start?"

The shaders are heart-stopping: Halftone CMYK with full CMYK color control, Grain Gradient for organic noise on gradient fills, Fluted Glass with convincing reeded-glass highlights, Liquid Metal with shape and angle control, Halftone Dots. Real-time, GPU-accelerated, native to the canvas — not plugins. Plus built-in AI image generation (Flux 2, Nano Banana Pro, OpenAI Image Edit 1.5, Seedream 4.5).

Why it doesn't make the daily-driver cut for swarm.ing: it's GUI-first, MCP-second. Your stack is CLI-first, MCP-as-bridge. Paper assumes the designer lives in Paper. You live in Claude Code. Also: PolyForm Shield license restricts use in competing products. If you ever want to bundle a design canvas into Openclaw — and you might, for the arena dashboard variant — read the license carefully.

Nexu-io built Open Design as the explicit open-source answer to Anthropic's Claude Design (Opus 4.7, April 2026 launch). The manifesto: "Same loop, same artifact-first mental model, none of the lock-in." It refuses to ship its own agent because the strongest coding agents already live on your laptop. The daemon scans your PATH on startup for 16 known coding-agent CLIs: claude, codex, devin, cursor-agent, gemini, opencode, qwen, qodercli, copilot, hermes, kimi, pi, kiro-cli, kilo, vibe-acp, deepseek. Whichever it finds become candidate design engines, swappable in the model picker.

The architecture mirrors yours: a TypeScript daemon, local SQLite under .od/, sandboxed preview iframe, optional Vercel deploy for the web layer, BYOK at every step. Skills follow Claude Code's SKILL.md convention — drop a folder into skills/, restart the daemon, it appears in the picker. The numbers shift between source counts: the README says 19 Skills + 71 Design Systems; the marketing site claims 217 Skills + 149 Design Systems + 5 visual directions. Either way: real brand libraries for Linear, Stripe, Vercel, Apple, Notion, Tesla, Airbnb, Cursor, Supabase, Figma, Spotify, and ~60 more.

"Whichever coding agent CLI you have installed becomes a candidate design engine. Swap with one click."

The pattern that separates Open Design from generic skill loaders: Junior Designer mode. Turn 1 is a structured question-form — surface, audience, tone, brand context, scale — before the model writes a single pixel. Direction picker offers 5 curated visual directions when the user has no brand (Monocle / Modern Minimal / Tech Utility / Brutalist / Soft Warm). Brand-asset protocol locates and grep-extracts hex values, writes a brand-spec.md, vocalizes it back. This is the disciplined version of "vibe design."

For swarm.ing: this is your runtime when (a) hosted token meters get tight, (b) you want to standardize a design loop across the team using whatever CLIs people already have installed (Hermes for some, Claude Code for others, Codex for a third), (c) you want to deploy the web layer on Vercel for stakeholders without exposing the agent infrastructure.

OpenCoworkAI's Open CoDesign hits the same target as Open Design but with a different bet: MIT license, Electron desktop app, signed binaries. Where Open Design assumes you'll pnpm tools-dev from a clone, Open CoDesign hands you a code-signed .dmg. Easier onboarding, more familiar shape for a designer who doesn't live in a terminal.

v0.2.0 (May 2026) is themed Agentic Design: every design becomes a "pi session" with JSONL history and a workspace folder on disk; permissioned agent loop with read/write/edit/bash/grep/find/ls gated by the app's UI; DESIGN.md is editable shared memory rather than model memory. Importantly: it reads existing Claude Code / Codex API-key provider configs and ChatGPT subscription users can sign in directly. Twelve built-in design skill modules ship out of the box.

The trade-off vs. Open Design: less CLI ceremony, more "app you launch." If swarm.ing wants to give a non-engineer team member a design tool that's BYOK without making them learn pnpm, this is the better fit. If you want a daemon you can SSH into and script, Open Design wins.

Claude Design launched April 17 2026 with Opus 4.7 (SWE-bench Verified 87%, IFEval rank 1, double-digit vision gains). The product is conversational: describe what you want → Claude generates a working interactive prototype on the canvas → refine via inline comments, direct text edits, or AI-emitted sliders → hand off to Claude Code with a single instruction as an implementation bundle (components, design tokens, copy, interaction notes). Brilliant's case study: complex pages that required 20+ prompts in other tools needed 2 prompts in Claude Design.

The genuinely new things: (1) design-system extraction — point Claude Design at a GitHub repo during onboarding, it reads tokens, components, typography, and applies them to every subsequent project; (2) code-aware handoff bundle — the most aligned design→code transition in the industry because both sides run on the same model family; (3) web capture tool grabs elements directly from a live website so prototypes look like the real product; (4) imports DOCX/PPTX/XLSX and codebase pointers.

"This is the first AI design tool that acts like it was built by people who also ship code."

The token meter is the catch. Claude Design has its own independent weekly limits, separate from your Pro/Max chat allowance. At serious iteration speed (the kind huashu-design or impeccable runs at because they're skills, not platforms) you'll burn through Pro pricing fast. Max ($100 or $200/month) makes it weekly-usable rather than every-now-and-then.

Where it fits in swarm.ing: non-technical handoffs. When you need to show Max or Tolsi a clickable prototype before any code exists, when a stakeholder needs to comment on a design without learning Figma, when the team wants to share a mockup in the org-shared canvas. It is not the daily driver for someone running Claude Code on a Mac Mini all day — that's what skills are for.

Stitch was Google's I/O 2025 reveal, evolved through the 2025 Galileo AI acquisition. The March 2026 v2.0 update added multi-screen generation, infinite canvas (versions sit side-by-side, not overwriting), voice capabilities on the canvas (speak design critiques in real time), brand-kit import, and an MCP server + SDK so you can leverage Stitch's capabilities from your own skills/tools. Powered by Gemini 3 in standard mode; experimental mode for higher-fidelity work.

The free-tier pitch is real: 350 standard generations + 200 experimental per month on Google Labs. That's enough for individual designers and small teams to do real work without paying anything. Multi-platform output covers web and mobile screens. Exports to HTML/CSS, Figma, and clean React code.

The weakness: editing. Stitch generates designs but you can't easily modify individual elements like you would in Figma — you regenerate with different prompts or adjust parameters. Token drift across multi-screen flows: screen 1 has correct button radius, screen 4 has a different one. Context-window evictions break consistency. Teams shipping production UIs hit this wall fast.

Magic Patterns positions explicitly against Claude Design: model-agnostic (your choice of underlying LLM), structured React output ready to drop into Claude Code, versioning core to the product (every generation saved as a branch, comparable, rollback-able). The MCP server lets agents hand off to Claude Code, Cursor, or any MCP-compatible coding agent. SOC 2 and ISO 27001 certified — relevant for swarm.ing's compliance work on Openclaw.

Live multiplayer is more mature than Claude Design's — multiple users see the same canvas, watch live cursors, and the page updates for everyone (sync or async). Comments anchor to specific elements and survive design rearrangement. Shareable preview links, password-protected, custom-domain hostable for client review without requiring Magic Patterns accounts.

Where it sits in your stack: if you ever need a hosted canvas that you can hand to Max or a contractor without giving them access to your Cloudflare/Fly.io infrastructure, this is the choice. Their MCP server means the handoff stays inside your existing agent workflow. For a 10–20 person AI lab, the SOC 2 / ISO 27001 posture matters more than it does for a solo dev.

superdesigndev/superdesign by @jasonzhou1993 and @jackjack_eth — open-source design agent that lives inside the IDE, runs parallel Claude Code agents on an infinite canvas. jonthebeef/superdesign-mcp-claude-code ships the MCP wrapper that wires it into Claude Code with no API key.

If you want to dissect how Pencil-style agentic canvases actually work — to maybe build a custom one for the Openclaw arena dashboard — this is the reference implementation to fork. Otherwise: stay on Pencil or Paper.

The skill marketplace fragmented in early 2026. The lists worth bookmarking:

For design specifically: rohitg00/awesome-claude-design (DESIGN.md prompts by aesthetic family, remix recipes, video teardowns), VoltAgent/awesome-claude-design (68 ready-to-use DESIGN.md design system inspirations including Linear, Raycast, Superhuman, Vercel, Warp, ClickHouse, Composio, HashiCorp, MongoDB).

General curated: ComposioHQ/awesome-claude-skills, BehiSecc/awesome-claude-skills, karanb192/awesome-claude-skills (definitive ~50 verified), travisvn/awesome-claude-skills, JayZeeDesign/awesome-claude-skills (with Anthropic's source-available document-skills/ folder).

Marketplaces: smithery.ai, agentskill.sh (claims 69k+ skills across Claude Code, Cursor, Copilot, Windsurf, Zed, 20+ tools), Claude Plugin Hub, MCP Market.

Specialist skills worth knowing about: Wholiver/swiftui-design-skill (SwiftUI anti-AI-slop, 6 rules, brand-asset protocol, 5D critique — install if you ever ship a Mac app for swarm.ing), rshankras/claude-code-apple-skills (Apple HIG compliance including Dynamic Island, safe areas, VoiceOver), Owl-Listener/designer-skills (MC Dean, MIT), Owl-Listener/designpowers (specialist design agents Direct + Auto modes), motion specialist skills based on Emil Kowalski's articles (emilkowal.ski).

Figma Make / Figma Agent (GA March 2026). Prompt-to-app is real, the MCP server exposes layout / images / variables to agents, and Code Connect lets the server return actual import statements when configured. But Figma Make's value depends on already living in Figma — which you don't. Output drifts from brand systems unless Code Connect is heavily invested in. For a shop where the brand lives in DESIGN.md and the agent loop runs in Claude Code, Figma Make is friction.

v0 by Vercel. Excellent for shadcn-heavy React projects. Collapses design and code into one step — which is its strength when you want a component-and-ship loop, but the wrong abstraction when you want to iterate visually before code. Magic Patterns covers the same niche with versioning and React structure.

Lovable / Bolt.new. Full-stack app generators. They include auth, database, deploy. Your stack already has Cloudflare Workers + D1 + Turnkey + NEAR Intents — you don't want Lovable picking the database for you. Skip.