TERMINAL ACCESS DENIED DESKTOP ENVIRONMENT REQUIRED

This secure reference terminal is optimised for desktop use. Return to this URL on a desktop system to gain full access.

REBOOT
Hypaspace Systems

Synthesising Code & Craft

39 open-source Claude Code skills for design and UI — what each does and when to use it.

39 Skills documented
10 skill groups
78 slash commands
Requires Claude Code
Navigation
Getting Started

These skills are open-source Claude Code plugins structured instruction sets that load into Claude and unlock specialised design capabilities. They come from a handful of well-maintained GitHub repos. Download the ones you need, drop them into your ~/.claude/skills/ folder, and they're available in every Claude Code session. Many are now also installable in one line from Anthropic's official marketplace with /plugin install — see Plugins & Marketplaces.

pbakaus
Impeccable
The core design quality toolkit 18 steering commands for auditing, polishing, animating, and hardening Claude-generated UIs. Built on top of Anthropic's frontend-design skill.
/audit /polish /normalize /harden /animate +13 more
arrow_outwardGrab this skill
Anthropic (official)
frontend-design
Anthropic's own skill that gives Claude a clear design direction before writing any code. Prevents the generic AI aesthetic Inter fonts, purple gradients, predictable layouts.
/frontend-design
arrow_outwardGrab this skill
nextlevelbuilder
UI/UX Pro Max
A searchable database of 50+ styles, 161 colour palettes, 57 font pairings, and 99 UX guidelines plus the full CKM suite of brand, design-system, slides, and banner skills.
/ui-ux-pro-max /ckm-brand /ckm-design-system +more
arrow_outwardGrab this skill
Anthropic (official)
Anthropic Skills Repo
The official Anthropic skills repository. Home to frontend-design and other first-party skills. The canonical source for Anthropic-maintained Claude skills.
/frontend-design + more
arrow_outwardGrab this skill
Emil Kowalski
emilkowalski/skill
A skill file based on the articles on Emil Kowalski's personal site. Covers animations, design, code, performance and the invisible details that separate good interfaces from great ones. Recommended for case-by-case use rather than always-on.
/emil-design-eng
arrow_outwardGrab this skill
Installation Guide
01
Make sure Claude Code is installed
Skills require Claude Code Anthropic's terminal-based coding agent. Install it globally via npm if you haven't already.
npm install -g @anthropic-ai/claude-code
02
Create your skills folder
Skills live in ~/.claude/skills/ for global access across all projects, or .claude/skills/ inside a project for project-scoped skills.
mkdir -p ~/.claude/skills
03
Download and install skills
Choose your preferred method. The plugin command is the fastest; manual install gives you more control.
# Install Impeccable (UI quality commands) /plugin marketplace add pbakaus/impeccable # Install Anthropic's frontend-design /plugin marketplace add anthropics/claude-code # Install UI/UX Pro Max /plugin marketplace add nextlevelbuilder/ui-ux-pro-max-skill # Install Emil Kowalski's design engineering skill npx skills add emilkowalski/skill # Clone Impeccable and copy skill to your folder git clone https://github.com/pbakaus/impeccable cp -r impeccable/dist/claude/.claude/skills/impeccable ~/.claude/skills/ # Clone frontend-design from Anthropic git clone https://github.com/anthropics/claude-code cp -r claude-code/plugins/frontend-design/skills/frontend-design ~/.claude/skills/ # Clone UI/UX Pro Max git clone https://github.com/nextlevelbuilder/ui-ux-pro-max-skill cp -r ui-ux-pro-max-skill/.claude/skills/ui-ux-pro-max ~/.claude/skills/ # Clone Emil Kowalski's skill git clone https://github.com/emilkowalski/skill cp -r skill ~/.claude/skills/emil-design-eng # Install the UI/UX Pro Max CLI globally npm install -g uipro-cli # Then run from your project directory cd /path/to/your/project uipro init --ai claude
04
Verify installation
Open Claude Code in your terminal and check that skills are available. Then try invoking one.
# Start Claude Code claude # List installed skills /skills list # Try a skill ask Claude to build something "Build me a landing page for a SaaS product, dark and editorial tone"
05
Skills activate automatically
You don't need to invoke skills by command name. Just describe what you want Claude reads the installed SKILL.md files and activates the right one based on context. You can also invoke them explicitly using the /command syntax shown in this guide.
rocket_launch
Where to start?
Install Impeccable first — it's the most complete design quality toolkit and the best single starting point. From there, add skills as you need them.
Grab Impeccable
info Using this directory

Browse the categories to understand what each skill does and when to reach for it. Use the search bar to find skills by name, use-case, or keyword. Once installed, invoke a skill by typing its /command name directly in Claude Code.

auto_fix_highUI Quality & Polish
6 skills

Quality skills work best when applied at the right stage, not all at once. Use /baseline-ui at the start, /audit mid-project, /harden before launch, and /polish last.

/baseline-ui
Prevent AI-generated slop before it starts
Run at project start to enforce quality standards upfront. Establishes a baseline that prevents generic AI aesthetic from creeping into the build.
Run firstSetup
/normalize
Realign after design drift accumulates
When components diverge from your design system over time, normalize realigns them. Use mid-project when things start to feel inconsistent.
Mid-projectDesign system
/distill
Strip back when UI is overbuilt or cluttered
Removes elements that don't earn their place. Use when the interface feels busy, bloated, or trying too hard. Forces honest editing.
DestructiveSimplification
/audit
Mid-project QA pass across all dimensions
Returns a scored report (P0–P3) across accessibility, performance, theming, and responsive behaviour. Essential before handoff or launch prep.
P0–P3 scoringA11yPerformance
/harden
Add error handling and edge case coverage before launch
Patches overflow, empty states, error boundaries, and edge cases. Turns a demo-quality UI into a production-safe one.
Pre-launchEdge cases
/polish
The final 10% pass before shipping
Tightens alignment, spacing, and micro-details that separate good from exceptional. Run last after all functional work is complete.
Run lastSpacingDetails
paletteDesign Enhancement
6 skills

Use these once your structure is solid and you need to shift the visual character. Each skill moves the design in a specific direction, so pick the one that matches what is wrong.

/bolder
UI feels safe, generic, or forgettable
Increases contrast, visual weight, and presence. Use when the design is technically correct but has no point of view or impact.
ContrastVisual weight
/quieter
UI feels aggressive or overwhelming
Tones down intensity without sacrificing quality. Pulls back colour, density, or animation to create breathing room.
RestraintBalance
/colourize
UI is too grey or monochromatic
Applies strategic colour intent not random colour, but purposeful use that communicates hierarchy, state, and brand.
ColourHierarchy
/arrange
Layout feels monotonous or flat
Fixes spacing, grid systems, and visual hierarchy. Addresses layouts that are structurally correct but visually dull.
GridHierarchySpacing
/typeset
Font or text hierarchy issues
Fixes typographic hierarchy, sizing, weight, and readability. Addresses everything from heading scales to body copy legibility.
TypographyReadability
/delight
Functional but joyless needs personality
Injects memorable moments, unexpected interactions, and personality. Use when the UI works well but feels robotic or impersonal.
PersonalityMemorable
animationMotion & Interaction
4 skills

Always design before you implement. Run /interaction-design first to define what should move and why, then /animate to build it. Motion without rationale becomes noise.

/interaction-design
Define transitions and feedback patterns before animating
The thinking step before /animate. Designs what should move, when, and why. Run this first to avoid aimless animation.
Run before /animatePatterns
/animate
Add purposeful motion after patterns are defined
Implements animation based on the interaction patterns defined. Purposeful, not decorative motion that communicates state and guides attention.
Run after /interaction-design
/fixing-motion-performance
Animations are janky or causing performance issues
Applies GPU layer promotion, will-change hints, and compositor-friendly properties. Fixes frame drops and visual stutters in existing animations.
PerformanceGPU
/overdrive
Showcase-level UI needing extraordinary motion
Shaders, spring physics, scroll-driven 60fps effects. Not for production apps for portfolio pieces, launch pages, and ambitious demos where motion IS the experience.
Showcase onlyShadersSpring physics
accessibility_newAccessibility & Standards
4 skills

Accessibility works best as a sequence. Fix UX copy with /clarify first, run a full audit with /wcag-audit-patterns, then patch specific issues with /fixing-accessibility.

/clarify
Confusing labels or error messages
Fixes UX writing before it reaches the formal audit. Rewrites ambiguous labels, placeholder text, and error messages for clarity.
Run before auditUX copy
/wcag-audit-patterns
Formal WCAG 2.2 accessibility audit
Comprehensive audit covering ARIA roles, keyboard navigation, colour contrast ratios, focus management, and screen reader compatibility.
WCAG 2.2ARIAKeyboard nav
/fixing-accessibility
Patch known accessibility issues in existing components
Targeted fixes for identified a11y problems. Use after /wcag-audit-patterns returns specific issues focussed remediation rather than full audit.
Use after auditTargeted fixes
/web-design-guidelines
Code review against web best practice standards
Reviews UI code against established web design and implementation guidelines. Broader than a11y covers semantics, performance patterns, and standards compliance.
Code reviewStandards
dashboardLayout & Performance
2 skills

Use /adapt when a desktop build needs to work across devices, and /optimize when performance scores or user feedback reveal slowness. Both are remediation skills, not upfront ones.

/adapt
Desktop-only UI needs cross-device support
Adds breakpoints, fluid layouts, and appropriate touch targets. Transforms desktop-first designs into genuinely responsive experiences.
ResponsiveMobileTouch
/optimise
UI is slow or laggy
Diagnoses and fixes bundle size, rendering bottlenecks, and image loading issues. Performance-first fixes, not cosmetic patches.
Bundle sizeRenderingImages
hubDesign Systems
3 skills

Design systems skills pay off on long-lived projects. Build your token architecture first with /ckm-design-system, consolidate patterns with /extract, and manage shadcn/ui components with /shadcn.

/ckm-design-system
Building a token system from scratch
Constructs a full token architecture: primitive → semantic → component layers. The correct foundation for any serious design system.
TokensPrimitivesArchitecture
/extract
Repeated patterns in the codebase
Identifies and consolidates repeated UI patterns into reusable components and design tokens. Reduces drift and improves maintainability.
DRYRefactorTokens
/shadcn
Any shadcn/ui project
Handles adding, searching, fixing, and styling shadcn components. The single skill to reach for on any project using shadcn/ui.
shadcn/uiComponents
psychologyFull-Stack Design Intelligence
6 skills

Start every significant build with /design-lab to explore directions before committing. These skills are the heaviest hitters in the set and produce the most distinctive output.

/design-lab
Explore directions before committing to a build
Generates 5 design directions to compare, plus runs a design interview to surface constraints. Use before any UI build starts to avoid expensive pivots.
Run before buildingExploration
/ui-ux-pro-max
Major design decisions needing comprehensive options
50+ styles, 161 palettes, 99 UX guidelines at your disposal. For significant design decisions where you need to see the full possibility space.
50+ styles161 palettes99 guidelines
/frontend-design
Building new UI from scratch
Production-grade UI generation with a deliberate aesthetic POV. Avoids generic AI aesthetic outputs distinctive, well-considered interfaces.
Build from scratchProduction
/interface-design
Dashboards, admin panels, and complex tools
Optimised for data-heavy, function-first interfaces. Not for marketing sites this is for tools, dashboards, and admin surfaces where clarity and density matter.
DashboardsToolsNot for marketing
/canvas-design
Static visual output posters, brand assets
Generates static visual output (PNG/PDF) rather than interactive UI. Use for posters, brand assets, print design, and design art.
StaticPrintBrand assets
/emil-design-eng
High-polish product UI the invisible details
Based on Emil Kowalski's articles on design engineering. Covers animations, micro-interactions, optical adjustments, and the invisible quality signals that separate good interfaces from great ones. Use on a case-by-case basis.
CraftsmanshipAnimationsMicro-details
person_checkUX & Onboarding
2 skills

/critique evaluates what you have built. /onboard shapes what new users encounter first. One looks back, the other looks forward.

/critique
UX evaluation after a design is built
Runs a scored UX evaluation with persona-based testing. Returns structured feedback on usability, clarity, flow, and friction points.
Post-buildPersonasScoring
/onboard
Building a first-run or activation experience
Designs empty states, activation flows, and new user experiences. Covers the critical first-use moment that determines whether users stick.
Empty statesActivationOnboarding
campaignBrand & Marketing
5 skills

Start brand work with /ckm-brand to establish strategic foundations before moving to execution. The other skills in this group build on top of that groundwork.

/ckm-brand
Brand strategy voice, messaging, visual identity
Strategic brand work: tone of voice, messaging frameworks, positioning, and visual identity direction. Foundation layer before any design execution.
StrategyVoicePositioning
/ckm-design
Full design projects logo, tokens, corporate identity
Logo generation across 55 styles, design tokens, and corporate identity systems. The full-service design skill for brand execution.
Logo55 stylesIdentity
/ckm-banner-design
Marketing assets social, ads, hero banners
Social media assets, advertising banners, hero images, and print materials. Consistent brand execution across marketing touchpoints.
SocialAdsPrint
/ckm-slides
Strategic presentations and slide decks
Builds strategic HTML presentations with Chart.js integration. Better output than PowerPoint templates narrative-driven, visually considered decks.
PresentationsChart.jsHTML
/ckm-ui-styling
shadcn + Tailwind component styling
Accessible, brand-accurate component styling for shadcn/Tailwind projects. Where /shadcn handles structure, this handles the aesthetic layer.
shadcnTailwindAccessible
devicesPlatform-Specific
1 skill

Platform-specific skills follow the conventions of their operating systems. Use /swiftui-ui-patterns for any iOS or macOS work to stay aligned with Apple Human Interface Guidelines.

/swiftui-ui-patterns
Any iOS or macOS SwiftUI work
Native Apple platform UI patterns, conventions, and best practices for SwiftUI. Keeps you aligned with HIG and platform expectations.
iOSmacOSSwiftUI
No skills match your search.

Pipelines are recommended sequences for common design and build workflows. Order matters running skills out of sequence produces weaker results. Each pipeline has been arranged to avoid redundant work.

Checklists & Pipelines

OP·7714·UI·BUILD 06 STEPS
Full UI Build Pipeline
Recommended order for building a new interface from scratch.
01/teach-impeccableSave design context once at project start
02/design-labExplore 5 directions before committing
03/baseline-uiEnforce quality standards upfront
04/frontend-designBuild the interface
05/animateAdd purposeful motion
06/polishFinal pass before ship
OP·7714·SHIP·CHK 05 STEPS
Pre-Ship Checklist
Run in order before any production deployment.
01/auditFind all issues across all dimensions
02/fixing-accessibilityPatch identified a11y problems
03/fixing-metadataSEO and OG tags
04/fixing-motion-performanceSmooth out animation jank
05/polishFinal pass
OP·7714·MOTION 03 STEPS
Motion Pipeline
Adding motion correctly — design before implementation.
01/interaction-designDefine transition patterns first
02/animateImplement based on patterns
03/fixing-motion-performanceFix any performance issues
OP·7714·A11Y 03 STEPS
Accessibility Pipeline
Full a11y pass from copy to code.
01/clarifyFix UX copy and labels first
02/wcag-audit-patternsFull WCAG 2.2 audit
03/fixing-accessibilityPatch identified issues
Glossary
Core design and UX/UI terms organised by discipline. Searchable alongside skills.
psychologyStrategy
22 terms
Accessibility (A11y)
Designing for people with disabilities, ensuring everyone can perceive, understand, and navigate the product.
Cognitive Load
The total amount of mental effort being used in working memory.
Design Sprint
A five-day structured process for solving design problems through ideation, prototyping, and user testing.
Design Thinking
A human-centred problem-solving approach with five stages: Empathise, Define, Ideate, Prototype, and Test.
Edge Case
A rare or extreme situation that a design must account for, such as an unusually long username.
Empathy Map
A tool used to articulate what we know about a particular type of user, creating shared understanding.
Happy Path
The ideal user journey where everything goes right and no errors occur.
High-fidelity (Hi-fi)
Detailed, near-final designs that closely represent the finished product, including real typography, colour, and interactions.
Information Architecture (IA)
The structural design of shared information environments; how content is organised and labelled.
Lean UX
An approach that prioritises rapid iteration and validated learning over extensive documentation, reducing waste in the design process.
Low-fidelity (Lo-fi)
Early-stage rough designs or wireframes with minimal visual detail, used for quick iteration and structural feedback.
Mental Model
What the user believes about how a system works. Good UX aligns the interface with this model.
Pain Point
A specific problem faced by current or prospective customers in the marketplace.
Prototype
A simulation of the final product used to test interactions and flows before development. Ranges from low-fidelity clickable mockups to high-fidelity coded versions.
Sitemap
A hierarchical diagram showing all pages or screens in a product and how they relate to one another.
User Experience (UX)
The internal experience a person has as they interact with every aspect of a company's services and products.
User Flow
A diagram mapping the steps a user takes to complete a specific task within a product, from entry point to completion.
User Interface (UI)
The graphical layout of an application, consisting of the buttons users click, the text they read, and the images.
User Journey Map
A visualisation of the process a person goes through to accomplish a goal.
User Persona
A fictional character created to represent a user type that might use a site or brand in a similar way.
User Story
A short, plain-language description of a feature from the user's perspective. Format: 'As a [user], I want to [action] so that [benefit].'
Wireframe
A low-fidelity skeletal layout showing the structure and placement of elements without visual design. The blueprint stage of UI design.
widgetsComponents
32 terms
Accordion
A list of headers that expand to reveal more content when clicked.
Badge
A small visual indicator, usually a number or dot, showing unread or new items.
Banner / Alert
A full-width message strip used to communicate important system-level information or status.
Bottom Sheet
A panel that slides up from the bottom of the screen on mobile, revealing additional content or actions.
Breadcrumbs
Secondary navigation showing the user's current location within a hierarchy.
Button
The most fundamental interactive element. Triggers an action. Variants include primary, secondary, ghost, destructive, and icon-only.
Card
A flexible container grouping related content (image, title, text, action) into one unit.
Carousel
A sliding container used to browse through multiple pieces of content horizontally.
Checkbox
A square control allowing users to select one or multiple options.
Chip / Tag
A compact element representing an attribute, filter, or selection. Often dismissible.
Contextual Menu
A menu that appears on right-click or long-press, offering actions relevant to the selected item.
Data Table
A structured grid for displaying, sorting, filtering, and interacting with tabular data sets.
Date Picker
A UI control allowing users to select a date or date range from a calendar interface.
Drawer
A panel that slides in from the side of the screen, typically used for navigation or supplementary content.
Dropdown
A menu that reveals a list of selectable options when activated.
Form
A container grouping input fields that collects and submits user data. Includes labels, inputs, validation, and a submit action.
Hamburger Menu
A three-line icon that toggles a hidden menu, common on mobile.
Input Field
A space where users can enter text or data.
Input Mask
A format that forces a user to enter data in a specific way, e.g. a phone number.
Loader / Spinner
An animation indicating that the system is busy processing.
Modal
A dialog box that overlays the main UI and requires an action before closing.
Navbar
A horizontal bar at the top of a screen containing primary links.
Pagination
A navigation pattern splitting large content sets into discrete pages with controls to move between them.
Progress Bar
A visual indicator showing how far through a process or task the user is.
Radio Button
A circular control allowing users to select exactly one option from a set.
Search Bar
An input field specifically for querying content, often with autocomplete and filter support.
Sidebar
A vertical navigation column on the left or right side of a page.
Stepper
A control to increase or decrease a numerical value, usually with + or - buttons.
Tab Bar
A row of buttons allowing users to switch between distinct views within the same context.
Toast / Snackbar
A small, temporary message at the edge of the screen providing contextual feedback.
Toggle / Switch
A digital on/off switch commonly used for settings.
Tooltip
A small label that appears on hover to explain a specific element.
toggle_onStates
11 terms
Active State
The visual state during the actual click or tap.
Default State
The base state of a component when no interaction is happening.
Disabled State
The state when a component exists but cannot be interacted with, often greyed out.
Empty State
What a component looks like when it has no data to display.
Error State
A red-themed state indicating a problem that needs to be fixed.
Focus State
The state when an element is selected via keyboard, crucial for accessibility.
Hover State
The state when a cursor is placed over an element. Desktop only.
Loading State
A state where the component is waiting for data to be fetched.
Skeleton State
A placeholder version of a component shown as grey pulses while content loads.
Success State
A green-themed state indicating a task was completed correctly.
Warning State
An orange or yellow state indicating a potential issue or caution.
paletteVisual
20 terms
Aspect Ratio
The proportional relationship between width and height, e.g. 16:9.
Border Radius
The measurement defining how rounded the corners of a component are.
Box Shadow
A visual effect that gives a component elevation or depth.
Colour System
A structured palette organising brand colours into primitives, semantic tokens, and component-level applications.
Font Weight
The thickness of a typeface's stroke. Common weights: 300 (light), 400 (regular), 600 (semibold), 700 (bold).
Grid System
Intersecting lines used to align and size components consistently.
Iconography
A consistent set of symbols and glyphs used to represent actions, objects, or concepts across a product.
Illustration
Custom artwork used to convey complex concepts, set tone, or add personality beyond what photography or icons can achieve.
Line Height
The vertical space between lines of text. Critical for readability. Also called leading.
Margin
The space on the outside of a component, separating it from others.
Opacity
The level of transparency of an element.
Padding
The space between the content of a component and its internal border.
Stroke / Border
The outline surrounding a component.
Touch Target
The actual clickable area of an element. Minimum 44x44px for mobile.
Type Scale
A defined set of font sizes with a consistent mathematical ratio, creating visual hierarchy across text elements.
Typography
The style, arrangement, and appearance of text.
Visual Hierarchy
The arrangement of elements to guide the eye and communicate order of importance.
Visual Weight
The perceived heaviness or prominence of an element based on size, colour, contrast, and position.
White Space
The empty space between elements that helps the design breathe.
Z-Index
The stack order of elements what sits on top of what.
animationMotion
14 terms
Affordance
A visual hint that suggests how to use an object, e.g. a button looks clickable.
Conditional Logic
If/Then rules that govern UI behaviour based on user input.
Duration
The length of time an animation takes to complete, measured in milliseconds.
Easing
The mathematical way an animation accelerates or decelerates, e.g. ease-in-out.
Entrance / Exit Animation
Animations that govern how elements appear (mount) and disappear (unmount) from the interface.
Friction
Anything that prevents a user from moving smoothly through a task.
Keyframe
A specific point in an animation sequence that defines a state. Intermediate frames are interpolated between keyframes.
Micro-interaction
A contained interaction moment with a trigger and response e.g. a like button animating on tap. The small details that make an interface feel alive.
Progressive Disclosure
Showing only the most necessary information first to avoid overwhelming the user.
Scroll-triggered Animation
An animation that activates based on the user's scroll position.
Signifier
The specific element that provides the affordance, e.g. the label or colour.
Spring Physics
An animation model that simulates real-world spring behaviour overshoot, bounce, and settle for natural-feeling motion.
Transition
An animated change between two states of a UI element or between two screens.
Validation
Checking if user input is correct. Client-side is instant; server-side is after submission.
hubSystems
19 terms
Asset
Any file used in the UI, such as SVG icons, PNGs, or Lottie animations.
Atomic Design
A design system methodology organising components into five levels: atoms, molecules, organisms, templates, and pages.
Auto Layout
A property that allows containers to shrink or grow based on their content.
Box Model
How browsers compute element size: content + padding + border + margin.
Breakpoint
The specific pixel width where a layout changes for different screen sizes.
Component Library
The repository of coded components that developers use to build.
Dark Mode
An alternate colour scheme using dark backgrounds and light foreground elements, reducing eye strain in low-light environments.
Design Drift
When the live product deviates from the original design files.
Design System
The single source of truth containing all components, tokens and rules.
Design Token
The smallest variable in a system, e.g. color-primary = #0052FF.
Documentation
Written instructions, examples, and guidelines that explain how to use a design system or component library.
Figma
The industry-standard collaborative design tool for UI/UX design, prototyping, and design system management.
Governance
The process and rules for managing contributions, changes, and decisions within a design system.
Handoff
The process of passing finished designs and assets to the engineering team.
Primitive Token
The raw, unassigned values in a system, e.g. Red-500.
Semantic Token
Naming colours by their purpose, e.g. button-bg-hover.
Single Source of Truth
A central repository where the definitive, up-to-date version of designs, tokens, or components is maintained.
Specs
Detailed measurements and annotations provided to the engineering team.
Style Guide
A document defining the visual rules of a product typography, colour, spacing, and component usage guidelines.
lab_researchResearch
15 terms
A/B Testing
Comparing two versions of a design to see which performs better.
Affinity Mapping
Organising research data into groups based on themes.
Card Sorting
A technique used to determine information architecture.
Fitts's Law
The time to acquire a target is a function of the distance to and size of the target.
Heatmap
A visual representation showing where users click and scroll on a page.
Hick's Law
The time it takes to make a decision increases with the number of choices.
Jakob's Law
Users prefer your site to work like all the others they already know.
Jobs to Be Done (JTBD)
A framework focusing on the underlying goal or 'job' a user is trying to accomplish, rather than their demographic profile.
NPS (Net Promoter Score)
A metric measuring how likely users are to recommend a product, scored on a scale of 0–10.
Qualitative Research
Research that explores user attitudes, motivations, and behaviours through interviews, observations, and open-ended methods.
Quantitative Research
Research that measures user behaviour numerically through analytics, surveys, and statistical methods.
Session Recording
A tool that captures user sessions to replay clicks, scrolls, and interactions for analysis.
Think-Aloud Protocol
A usability testing method where participants verbalise their thoughts as they interact with a product.
Tree Testing
Evaluating the findability of topics within a site's structure.
Usability Testing
Observing real users attempting tasks in a product to identify friction, confusion, and areas for improvement.
accessibility_newA11y
11 terms
Alt Text
Text descriptions of images for visually impaired users.
ARIA Label
Hidden text used by screen readers to describe non-text elements.
Colour Blindness
A vision condition affecting colour perception. Designs must not rely solely on colour to convey meaning.
Contrast Ratio
The difference in luminance between text and background. WCAG AA requires 4.5:1.
Focus Order
The logical sequence a user follows when navigating via keyboard.
Keyboard Navigation
The ability to operate all interactive elements using only a keyboard, essential for motor-impaired users.
Localisation (L10n)
Adapting a design for different languages and cultures, e.g. right-to-left layouts.
Reduced Motion
A user preference (prefers-reduced-motion) that signals animations should be minimised or removed.
Screen Reader
Assistive software that reads on-screen content aloud for visually impaired users. Examples: NVDA, VoiceOver, JAWS.
Skip Link
A hidden link that becomes visible on keyboard focus, allowing users to skip past repetitive navigation directly to main content.
WCAG AA
The standard accessibility conformance level requiring 4.5:1 contrast for normal text and 3:1 for large text.
trending_upBusiness
18 terms
Agentic UI
Interfaces designed for AI agents that perform multi-step tasks autonomously.
AI Guardrails
Constraints and rules applied to AI systems to prevent harmful, off-topic, or undesirable outputs.
Churn Rate
The rate at which customers stop using your product.
Context Window
The maximum amount of text (tokens) an AI model can process in a single interaction. Determines how much information Claude can 'remember' within a conversation.
Conversion Rate
The percentage of users who complete a desired action.
Few-shot Prompting
Providing an AI with a small number of examples within the prompt to guide its output format or reasoning.
Hallucination
When an AI model generates confident but factually incorrect or invented information.
KPI
Key Performance Indicator. A quantifiable measurement used to gauge product success.
LLM Transparency
Showing when an AI is reasoning or where its data originates.
Micro-copy
The small bits of text such as button labels and hints that guide the user.
Multimodal Interface
An interface supporting voice, touch, gesture, and other input types simultaneously.
Prompt Engineering
The practice of crafting precise, structured inputs to get the most accurate and useful outputs from an AI model.
RAG (Retrieval-Augmented Generation)
A technique that enhances AI responses by retrieving relevant documents from a knowledge base before generating a reply.
ROI
Return on Investment. The financial gain achieved from a design improvement.
Spatial Computing
Designing for 3D environments such as AR, VR, and MR.
System Prompt
Instructions given to an AI at the start of a session that define its behaviour, tone, and constraints for the entire conversation.
Vibe Coding
A development approach where you describe what you want in natural language and an AI generates the code, focusing on the outcome rather than the implementation.
Zero-shot Prompting
Asking an AI to complete a task without providing any examples, relying entirely on the model's training.
Slash Commands
Every command Claude Code ships with, grouped by what you're actually trying to do. Click any command to copy it. Built-in commands are part of the CLI; bundled skills ship with it but load only when invoked.
COMMAND REGISTRY 78 COMMANDS  ·  9 CLASSES  ·  CLI v2.1 ▓ VERIFIED ▓
search 78 shown
layers Session & Context Managing the conversation and its context window 14 expand_more
/clear [name]Start a new conversation with empty context.
/compact [instructions]Free up context by summarising the conversation so far.
/autocompact [auto|tokens]Set how full the context window gets before Claude Code compacts automatically.
/context [all]Visualise current context usage as a coloured grid.
/resumeReturn to an earlier conversation.
/rewindRoll code and conversation back to a checkpoint, or summarise part of the conversation.
/branch [name]Branch the conversation here, so you can try a different direction without losing what you have.
/fork [prompt]Copy the conversation into a new background session and keep working here.
/background [prompt]Detach the session to run as a background agent and free this terminal.
/recapGenerate a one-line summary of the current session on demand.
/export [filename]Export the current conversation as plain text.
/copy [N]Copy the last assistant response to the clipboard.
/focusToggle focus view — only your last prompt, a one-line tool summary, and the final response.
/btw [question]Ask a side question about the session without adding it to the conversation.
tune Model & Output Choosing how hard and how fast Claude thinks 6 expand_more
/model [model]Switch the model and save it as your default for new sessions.
/effort [level|auto]Set the model effort level.
/fast [on|off]Toggle fast mode — Opus with faster output, not a smaller model.
/advisor [model|off]Consult a second model for guidance at key moments during a task.
/config [key=value]Open Settings to adjust theme, model, output style, and other preferences.
/color [color|default]Set the prompt bar colour for the current session.
account_tree Planning & Delegation Scoping work, then handing it to agents 9 expand_more
/plan [description]Enter plan mode directly from the prompt.
/goal [condition|clear]Set a goal — Claude keeps working across turns until it's met or judged impossible.
/subtask [prompt]Hand a task to a subagent that reports back to this conversation.
/tasksList background work, including subagents that have finished.
/list-agentsList the subagents and other sessions Claude can message, with the name to use for each.
/agentsPrints a reminder to ask Claude to create or manage subagents, or edit .claude/agents/ directly.
/loop [interval] [prompt]Run a prompt repeatedly while the session stays open.
/batch <instruction>Orchestrate large-scale changes across a codebase in parallel.
/verifyVerify code against a test suite.
rule Code Review & Quality Checking the diff before it ships 6 expand_more
/code-review [level] [--fix] [--comment]Review the current diff, or a PR, branch, or path, for correctness bugs and cleanup opportunities.
/reviewAlias for /code-review.
/security-reviewCheck the diff for security vulnerabilities.
/simplify [path]Suggest code simplifications and refactorings.
/diffOpen an interactive diff viewer showing uncommitted changes and per-turn diffs.
/debug [description]Enable debug logging and troubleshoot by reading the session debug log.
folder_managed Project Setup & Memory Teaching Claude about this codebase, once 9 expand_more
/initInitialise the project with a CLAUDE.md guide.
/memoryEdit CLAUDE.md files, toggle auto memory, and view auto memory entries.
/add-dir <path>Add a working directory for file access during the current session.
/cd <path>Move the session to a new working directory, keeping the conversation and prompt cache.
/permissionsManage allow, ask, and deny rules for tool permissions.
/hooksView hook configurations for tool events.
/keybindingsOpen your keyboard shortcuts file.
/doctorRun a setup checkup that diagnoses issues and can fix them.
/fewer-permission-promptsScan transcripts for common read-only calls, then build an allowlist to cut permission prompts.
extension Extending Claude Skills, plugins, MCP servers, and integrations 8 expand_more
/plugin [subcommand]Manage Claude Code plugins.
/reload-plugins [--force]Reload active plugins to apply pending changes without restarting.
/reload-skillsRe-scan skill and command directories so newly added skills take effect.
/mcp [reconnect|enable|disable]Manage MCP server connections and OAuth authentication.
/install-github-appInstall the Claude GitHub App for a repo, optionally setting up Actions workflows and secrets.
/install-slack-appInstall the Claude Slack app.
/chromeConfigure Claude in Chrome settings.
/ideManage IDE integrations and show status.
palette Design & Research The design-adjacent bundled skills 5 expand_more
/design-sync [hint]Convert your repo's React design system and upload it to Claude Design, so generated designs use your real components.
/design-loginAuthorise design-system access for /design-sync with your claude.ai account.
/dataviz [request]Design guidance for charts, graphs, and dashboards.
/claude-api [migrate|prompt-audit]Load Claude API and Managed Agents reference material for your project's language.
/deep-research <question>Fan out web searches, cross-check sources, and synthesise a cited report.
devices Cross-Device & Web Moving a session between terminal, desktop, cloud, and phone 5 expand_more
/desktopContinue the current session in the Claude Code Desktop app.
/teleportPull a web session into this terminal.
/remote-controlContinue this local session from another device.
/mobileShow a QR code to download the Claude mobile app.
/autofix-pr [prompt]Spawn a cloud session that watches the branch's PR and pushes fixes when CI fails or reviewers comment.
monitoring Account, Cost & Diagnostics Auth, spend, and everything housekeeping 16 expand_more
/loginSign in to your Anthropic account.
/logoutSign out from your Anthropic account.
/usageShow API usage and costs.
/costAlias for /usage.
/statusShow session status.
/privacy-settingsView and update your privacy settings.
/upgradeUpgrade Claude Code.
/release-notesView the changelog in an interactive version picker.
/insightsGenerate an HTML report analysing your recent sessions — where you work and where things go wrong.
/powerupLearn Claude Code features through quick interactive lessons with animated demos.
/helpShow help and available commands.
/feedback [report]Send product feedback about Claude Code.
/passesShare a free week of Claude Code with friends.
/heapdumpWrite a heap snapshot and memory breakdown to ~/Desktop for diagnosing high memory usage.
/radioOpen Claude FM lo-fi radio in your browser.
/exitExit the CLI.
NO MATCHING COMMANDS — try a shorter query.
Built-in command Bundled skill — loads on invoke
Plugins & Marketplaces
Manually copying skill folders still works, but it's no longer the main way skills travel. A plugin bundles skills, subagents, hooks, and MCP servers into one versioned, installable unit — and Anthropic's official marketplace now carries 286 of them, including frontend-design itself.
INSTALL PROTOCOL 2 STAGES  ·  MARKETPLACE → PLUGIN ▓ RECOMMENDED ▓
STAGE 01
Add a marketplace
Registers a catalogue so you can browse it. Nothing is installed yet. The official Anthropic marketplace is added automatically on first interactive launch.
STAGE 02
Install what you want
Pick a scope: user (all your projects), project (shared with collaborators via .claude/settings.json), or local (this repo, just you).
# Browse the plugin manager — Discover / Installed / Marketplaces / Errors tabs
/plugin

# Install from the official marketplace
/plugin install frontend-design@claude-plugins-official

# Add the community marketplace, then install from it
/plugin marketplace add anthropics/claude-plugins-community
/plugin install <name>@claude-community

# Any GitHub repo with .claude-plugin/marketplace.json works as a marketplace
/plugin marketplace add owner/repo

# Manage without opening the panel
/plugin list
/plugin disable <name>@<marketplace>
/plugin uninstall <name>@<marketplace>
/reload-plugins        # apply changes without restarting
Trust warning: plugins execute arbitrary code with your user privileges. Anthropic doesn't verify third-party plugins or the MCP servers they bundle. Only install from sources you trust — and check the Context cost figure in the details pane, since every plugin adds tokens to each turn.
DESIGN-RELEVANT OFFICIAL PLUGINS SOURCE: claude-plugins-official
frontend-designAnthropic's own distinctive-frontend skill — the same one this site catalogues, now installable in one line.
figmaFigma platform integration: read design files, extract component info. Replaces manual MCP setup.
canvaCreate, edit, resize, and brand-check Canva designs.
superdesignDesign or redesign frontend UI and marketing graphics on an infinite canvas.
ui-theme-designerTwo bundled skills for building and applying UI themes.
modern-web-guidanceKeeps the agent current on web best practices — a standing counterweight to stale patterns.
playgroundGenerates self-contained single-file HTML explorers — useful for testing a component in isolation.
chrome-devtools-mcpDrives a real Chrome and records performance traces — the honest way to verify motion performance.
playwrightBrowser automation and end-to-end testing, for checking real rendered output.
skill-creatorCreate, improve, and measure your own skills — the fastest route from repeated prompt to reusable skill.
plugin-devSeven expert skills for packaging your own work as a distributable plugin.
pr-review-toolkitSpecialised review subagents for comments, tests, and error handling.
Browse the full catalogue at claude.com/plugins or via the /plugin Discover tab
Subagents
A skill runs inside your conversation. A subagent runs in its own fresh context window and returns only a summary — so verbose work (sweeping a codebase, auditing every component) doesn't flood the context you're actually working in. For design work, this is how you run five parallel reviews without paying for five transcripts.
AGENT DEFINITION MARKDOWN + YAML FRONTMATTER
.claude/agents/This project. Commit these so the team shares and improves them together — the recommended default.
~/.claude/agents/All your projects. Personal agents.
plugin agents/Provided by an enabled plugin. Lowest priority — a same-named project or user agent overrides it.
nameREQUIREDLowercase letters and hyphens. The identifier you invoke and that hooks match on.
descriptionREQUIREDWhen Claude should delegate here. Write it as a trigger condition, not a job title.
toolsAllow-list, e.g. Read, Grep, Glob. Omit to inherit everything. A read-only reviewer should never hold Write.
modelsonnet, opus, haiku, fable, or a full model ID. Defaults to inheriting yours.
skillsSkills to preload into the agent's context at startup — how you hand a reviewer your design system up front.
memoryuser, project, or local — persistent memory scope across invocations.
isolationSet to worktree to run in its own git worktree, so parallel agents can't collide on files.
maxTurnsHard cap on agentic turns before it stops.
// .claude/agents/design-reviewer.md
---
name: design-reviewer
description: Reviews rendered UI against the design system. Use after any component change.
tools: Read, Grep, Glob
model: sonnet
skills:
  - frontend-design
memory: project
---

You are a design reviewer. For every issue, name the token or rule
it violates, quote the offending code, and give the corrected version.

Check spacing scale adherence, type hierarchy, contrast ratios,
and interaction states. Be specific — never say "improve spacing".
# Three ways to invoke
Use the design-reviewer agent to check my changes   # natural language
@"design-reviewer (agent)" audit the settings panel  # explicit, guaranteed
claude --agent design-reviewer                       # as the main thread
WHICH ONE DO I WANT SUBAGENT vs SKILL
Reach for a subagent
  • The task produces verbose output you'll never re-read
  • You want to enforce tool restrictions, not just request them
  • Work is self-contained and a summary is enough
  • You need several running in parallel, isolated from each other
Reach for a skill
  • You want the expertise live in your own conversation
  • The task needs back-and-forth refinement
  • Multiple phases share significant context
  • You'll invoke it as a /command
What a subagent does not inherit: your conversation history, skills you've already invoked, or your auto memory. It gets its own system prompt, the delegation message, your CLAUDE.md hierarchy, and any preloaded skills. Anything else it needs, you must put in the prompt.
Hooks
A preference in CLAUDE.md is a request Claude can forget. A hook is a rule the harness enforces — shell commands that fire deterministically on session events. This is the only reliable way to get "always run the formatter after an edit" or "never let it touch that directory".
EVENT BUS THE ONES YOU'LL ACTUALLY USE ▓ DETERMINISTIC ▓
PreToolUseBefore a tool call runs — and it can block it. Where guardrails go.
PostToolUseAfter a tool call succeeds. Lint, format, rebuild tokens, regenerate a preview.
PostToolUseFailureAfter a tool call fails. Useful for capturing diagnostics.
UserPromptSubmitBefore your prompt is processed — inject context, or validate what you asked for.
SessionStart / SessionEndSession begins or resumes / terminates. Warm a dev server, tear it down.
StopClaude has finished responding. Fire a notification, open a browser, run the build.
SubagentStart / SubagentStopA subagent spawns / finishes.
PreCompact / PostCompactAround context compaction — snapshot state before it's summarised away.
FileChangedA watched file changed on disk.
PermissionRequestA tool call needs a permission decision.
31 events exist in total — see the hooks reference for the full bus
CONFIGURATION settings.json  ·  3 LEVELS OF NESTING
// .claude/settings.json — run the formatter after every write
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npm run lint:fix",
            "statusMessage": "Formatting…",
            "timeout": 30
          }
        ]
      }
    ]
  }
}
commandShell command. Receives the event as JSON on stdin — pipe through jq to read fields.
httpPOSTs the event JSON to an endpoint.
mcp_toolCalls a tool on a connected MCP server.
promptHands the event to a model for a single-turn judgement.
~/.claude/settings.jsonAll your projects. Local to this machine, not shareable.
.claude/settings.jsonThis project — commit it, and the whole team gets the rule.
.claude/settings.local.jsonThis project, gitignored. Your own overrides.
plugin hooks/hooks.jsonBundled with a plugin — same format as the hooks object above.
skill / subagent frontmatterScoped to the rest of the session once invoked, or to the agent's lifetime.
Why this matters for design work: "always regenerate tokens after editing the theme file" or "screenshot the page after every component change" cannot be enforced by asking. As a PostToolUse hook, it happens every time, whether or not the model remembers. Set "disableAllHooks": true to kill them all temporarily.
Artifacts
Terminal scrollback is a poor medium for design work. An artifact publishes a live, interactive page from your session to a private URL on claude.ai — so four layout options sit side by side in a browser instead of being described in prose. It updates in place as the session continues.
PUBLISH PIPELINE SESSION → PRIVATE PAGE → SHARED LINK ▓ PRO / MAX / TEAM ▓
STAGE 01
Ask in plain language
No command. Describe the visual output you want. Claude writes an .html or .md file into your project, then asks permission to publish it.
STAGE 02
Iterate in place
Ask for revisions and it republishes to the same URL. Every publish is a version, and you choose which one viewers see. Ctrl+] reopens the latest.
STAGE 03
Share deliberately
Private to you by default. Share from the page header — to named people, your whole org, or a public link. Team/Enterprise can add editors.
# Compare options instead of describing them
Make an artifact with four distinctly different layouts for the settings
panel. Vary density and grouping, lay them out as a grid with a one-line
tradeoff under each.

# Tune values directly rather than guessing
Build an artifact with sliders for the easing curve, duration and delay
so I can try values on this transition. Show the animation live.

# Bring the decision back into the session
Make a triage board with each issue as a draggable card. Add a
"Copy as prompt" button that gives me the final ordering to paste back.

# Update one from a different session — the URL is required
Update https://claude.ai/code/artifact/<id> with today's numbers.
It applies a design skill automatically — and looks for your project's design system before choosing its own. Record your tokens in CLAUDE.md and artifacts come out on-brand: your system outranks its defaults, and your prompt outranks both.
PAGE CONSTRAINTS ONE SELF-CONTAINED FILE UNDER STRICT CSP
No external requestsThe CSP blocks other hosts entirely — scripts, stylesheets, images, fetch, XHR, WebSockets. CSS and JS are inlined; images become data URIs. Google Fonts is the single exception.
No backendStatic page. It can't store form input or authenticate viewers. Its only route to live data is calling MCP connectors.
Single pageRelative links don't resolve — multi-section content uses in-page anchors.
File types.html, .htm, or .md. Markdown renders as styled HTML.
Size ceiling16 MiB rendered. Large embedded raster images are the usual cause of a failed publish — prefer SVG or CSS.
Live dataA page can call MCP connectors on load, through each viewer's own account. Two people can see different data. Connector-backed pages can never be shared publicly.
Plan & authPro, Max, Team, or Enterprise, signed in with /login. API-key and gateway sessions cannot publish.
ProviderAnthropic API only — not Bedrock, Vertex, or Foundry.
Turning it off"disableArtifact": true, or CLAUDE_CODE_DISABLE_ARTIFACT=1, or deny the Artifact permission.
Your gallery lives at claude.ai/code/artifacts
Connectors
MCP connectors extend Claude beyond the terminal linking it directly to design tools, codebases, and storage. These are the ones that meaningfully improve design and build workflows.
INTEGRATION MAP 5 NODES ACTIVE  ·  MCP PROTOCOL
SYS:NODE·00
CLAUDE
CORE SYSTEM
ONLINE
GitHub Version control MCP:HTTP
Read repos, push code, review PRs
Google Drive Asset storage NATIVE
Brand assets, DESIGN.md, style guides
Canva Marketing assets NATIVE
Social assets, ads, presentation decks
Supabase Backend NATIVE
Schema-aware UI, queries, types
Context Files
Skills teach Claude how to do things. Context files tell it what to work with. Together they produce consistent, on-brand output across every session.
CLAUDE.md
Project memory & preferences
A plain markdown file that Claude Code reads at the start of every session. Put your stack, conventions, file structure, and preferences here so Claude always has the right baseline no re-explaining each session.
Example contents
# Project Stack: Next.js 14, Tailwind, shadcn/ui Design tokens: tokens/design.ts Component folder: src/components/ # Preferences - Use TypeScript strict mode - Prefer composition over prop drilling - Save output files to ~/Claude/
Location: ~/.claude/CLAUDE.md (global) or .claude/CLAUDE.md (project)
DESIGN.md
Brand & visual system
A structured file describing your brand's visual language colours, typography, spacing, component patterns, tone. Claude reads it before generating any UI, ensuring every output stays on-brand without repeated instructions.
Example contents
# Brand Name: Hypaspace Tone: Bold, technical, minimal # Colours Primary: #6f6af8 Background: #0b0b0f Surface: #111117 # Typography Display: Special Gothic Expanded One Body: Syne Mono: JetBrains Mono
Location: project root or attach in chat · getdesign.md for templates
SKILL.md
Custom skill definition
The format that all skills use. You can write your own encode your team's workflow, brand standards, or domain expertise as a reusable skill. Any folder with a SKILL.md becomes a Claude skill.
Minimal structure
--- name: my-skill description: When to activate this skill --- # My Skill Instructions for Claude go here. Reference files, examples, and decision frameworks all valid.
Location: ~/.claude/skills/my-skill/SKILL.md
How Skills Work
A primer for anyone new to the Claude skills system.
SKILLS — SYSTEM SPEC  ·  REV 2.0 8 ENTRIES LOADED
SKILL.md
FOLDER + FILE
──▶
SESSION LOAD
~100 TOKENS
──▶
CONTEXT MATCH
AUTOMATIC
──▶
EXECUTE
OR /COMMAND
──▶
OUTPUT
SPECIALISED
S-01 A skill is a folder containing a SKILL.md file plus any supporting scripts, data, or references. Claude reads these at session start and uses them as specialised knowledge for specific tasks.
S-02 You don't invoke most skills by name. Claude reads all installed SKILL.md files and activates the right one based on your request. Ask it to build a landing page and the frontend skill fires. Ask for an audit and the right commands are reached for.
S-03 Skills load ~100 tokens at session start — far less than an equivalent MCP server. Multiple skills can be active simultaneously without significant performance impact. Prefer skills over MCP where both could solve the problem.
S-04 A skill is just markdown. Repeating the same context, preferences, or instructions across sessions? Those belong in a skill. Encode your design system, component patterns, team conventions — available in every session.
S-05 Prompts are one-shot. Skills persist across sessions, activate by context. MCP servers give live tool access (APIs, databases) but consume more tokens. Use skills for reusable expertise; MCP for live data.
S-06 Skills require the terminal-based agent, not claude.ai. If using the web UI, the equivalent is uploading reference documents or writing a system prompt. Install via npm install -g @anthropic-ai/claude-code.
S-07 Custom slash commands have been merged into skills. .claude/commands/deploy.md and .claude/skills/deploy/SKILL.md both produce /deploy and behave identically — existing commands/ files keep working. Skills just add more: a folder for supporting files, frontmatter to control whether you or Claude invokes them, and automatic loading when relevant.
S-08 Dropping a folder in ~/.claude/skills/ still works and is still the fastest way to iterate. But to share a skill — with a teammate or the community — bundle it as a plugin and distribute it through a marketplace. Plugin skills are namespaced as /plugin-name:skill-name so two plugins can ship the same skill name without colliding. See Plugins & Marketplaces.
DIRECTORY ~/.claude/
~/.claude/
├── CLAUDE.md ← global config
├── skills/
│ ├── frontend-design/
│ │ └── SKILL.md
│ ├── ui-ux-pro-max/
│ │ └── SKILL.md
│ ├── audit/
│ │ └── SKILL.md
│ └── polish/
│ └── SKILL.md
└── projects/
└── my-app/
└── CLAUDE.md ← project config
DROP ZONE
Any folder with a SKILL.md inside ~/.claude/skills/ is live on next session start. No config required.
Tips & Gotchas
Things that aren't obvious until you've hit them.
FIELD DISPATCH LOG 8 ENTRIES  ·  CLEARANCE: LEVEL 2 ▓ CONFIDENTIAL ▓
WARN 001 Order matters in pipelines
Running /polish before /harden wastes effort — harden changes structure, polish changes surface. Run /audit/harden/polish, in that order, every time.
WARN 002 Too many active skills = token bloat
Skills load ~100 tokens each at session start. 5–10 skills is fine. 30+ starts affecting context budget meaningfully. Keep only what you actively use global; put project-specific skills in the project folder.
WARN 003 /overdrive is for showcases only
Shaders and spring physics are expensive and inappropriate for production apps. /overdrive is for portfolio pieces, launch demos, and contexts where motion IS the product. Don't reach for it on functional tooling.
NOTE 004 Set context once with /teach-impeccable
Running /teach-impeccable at project start saves your design context to config so every subsequent skill has it. Skip this and you'll be re-explaining your design system on every command.
NOTE 005 Run /design-lab before /frontend-design
It's tempting to jump straight to building. Don't. Spending 5 minutes in /design-lab exploring directions prevents hours of creative pivots later. The 5 directions it generates are cheap; rebuilding a committed design isn't.
NOTE 006 Figma MCP requires a restart
MCP servers initialise at Claude Code startup. If you add the Figma connector mid-session and it doesn't appear, fully restart Claude Code. Also disconnect any duplicate Figma instances — the desktop plugin and remote MCP can conflict.
WARN 007 Figma MCP is read-only in some setups
The write-to-canvas and code-to-canvas features require the remote MCP server, not the desktop version. If you're on desktop MCP and write features aren't working, switch to mcp.figma.com/mcp.
NOTE 008 Prefer skills over MCP for design context
If you're tempted to use an MCP server just to provide design context, a DESIGN.md + skill is almost always better — lighter, faster, and portable across projects. Reserve MCP for live data that genuinely needs an API.