PluginBench
Skill
Official
Pass
Audit score 90

design-system

anthropics/knowledge-work-plugins

Audit, document, or extend your design system with consistency checks and component documentation.

What is design-system?

Manage your design system by auditing components for consistency, documenting variants and states, or designing new patterns that fit your existing system. Use this when checking for naming inconsistencies, hardcoded values, or creating component documentation with accessibility notes.

  • Audit design systems for naming consistency and hardcoded token values across components
  • Document components with variants, states, properties, and accessibility requirements
  • Design new components or patterns that align with existing system constraints
  • Generate structured output for component completeness scoring and priority improvements
  • Track design tokens (colors, typography, spacing, borders, shadows, motion) across the system

How to install design-system

npx skills add https://github.com/anthropics/knowledge-work-plugins --skill design-system
Claude Code
Cursor
Windsurf
Cline

How to use design-system

  1. 1.Run `/design-system audit` to review your entire system for consistency issues and token coverage
  2. 2.Run `/design-system document [component-name]` to generate structured documentation for a specific component
  3. 3.Run `/design-system extend [pattern-name]` to design a new component that fits your existing system
  4. 4.Review the generated audit report to prioritize naming fixes and token standardization
  5. 5.Use the component documentation template to add accessibility, variants, and usage examples

Use cases

Good for
  • Identify and fix naming inconsistencies across button, input, and other component variants
  • Document a new component's props, states, and keyboard interactions for team reference
  • Audit a design system to find hardcoded hex colors or arbitrary spacing values that should use tokens
  • Design a new form pattern that reuses existing components and tokens
  • Create accessibility documentation (ARIA roles, keyboard behavior) for screen reader users
Who it's for
  • Design system maintainers and leads
  • Frontend engineers building component libraries
  • Product designers documenting design patterns
  • Teams standardizing component naming and token usage

design-system FAQ

What should I audit first?

Start with a full system audit using `/design-system audit` to identify naming inconsistencies, hardcoded values, and component completeness gaps before prioritizing improvements.

How do I document a component's accessibility?

The document output includes an Accessibility section with ARIA role, keyboard behavior (Tab, Enter, Escape), and screen reader announcements. Fill these based on your component's implementation.

Can this skill connect to design tools like Figma?

If a design tool connector is available, you can audit components directly in Figma and pull component properties and layer structure for documentation.

What's the difference between audit, document, and extend?

Audit checks your entire system for consistency and token coverage; document creates structured reference material for existing components; extend designs new components that fit your system.

How do I know which tokens to use in a new component?

The extend output includes a 'Tokens Used' section listing required colors, spacing, and typography tokens. Reference your design token definitions to ensure consistency.

Full instructions (SKILL.md)

Source of truth, from anthropics/knowledge-work-plugins.


name: design-system description: Audit, document, or extend your design system. Use when checking for naming inconsistencies or hardcoded values across components, writing documentation for a component's variants, states, and accessibility notes, or designing a new pattern that fits the existing system. argument-hint: "[audit | document | extend] <component or system>"

/design-system

If you see unfamiliar placeholders or need to check which tools are connected, see CONNECTORS.md.

Manage your design system — audit for consistency, document components, or design new patterns.

Usage

/design-system audit                    # Full system audit
/design-system document [component]     # Document a component
/design-system extend [pattern]         # Design a new component or pattern

Components of a Design System

Design Tokens

Atomic values that define the visual language:

  • Colors (brand, semantic, neutral)
  • Typography (scale, weights, line heights)
  • Spacing (scale, component padding)
  • Borders (radius, width)
  • Shadows (elevation levels)
  • Motion (durations, easings)

Components

Reusable UI elements with defined:

  • Variants (primary, secondary, ghost)
  • States (default, hover, active, disabled, loading, error)
  • Sizes (sm, md, lg)
  • Behavior (interactions, animations)
  • Accessibility (ARIA, keyboard)

Patterns

Common UI solutions combining components:

  • Forms (input groups, validation, submission)
  • Navigation (sidebar, tabs, breadcrumbs)
  • Data display (tables, cards, lists)
  • Feedback (toasts, modals, inline messages)

Principles

  1. Consistency over creativity — The system exists so teams don't reinvent the wheel
  2. Flexibility within constraints — Components should be composable, not rigid
  3. Document everything — If it's not documented, it doesn't exist
  4. Version and migrate — Breaking changes need migration paths

Output — Audit

## Design System Audit

### Summary
**Components reviewed:** [X] | **Issues found:** [X] | **Score:** [X/100]

### Naming Consistency
| Issue | Components | Recommendation |
|-------|------------|----------------|
| [Inconsistent naming] | [List] | [Standard to adopt] |

### Token Coverage
| Category | Defined | Hardcoded Values Found |
|----------|---------|----------------------|
| Colors | [X] | [X] instances of hardcoded hex |
| Spacing | [X] | [X] instances of arbitrary values |
| Typography | [X] | [X] instances of custom fonts/sizes |

### Component Completeness
| Component | States | Variants | Docs | Score |
|-----------|--------|----------|------|-------|
| Button | ✅ | ✅ | ⚠️ | 8/10 |
| Input | ✅ | ⚠️ | ❌ | 5/10 |

### Priority Actions
1. [Most impactful improvement]
2. [Second priority]
3. [Third priority]

Output — Document

## Component: [Name]

### Description
[What this component is and when to use it]

### Variants
| Variant | Use When |
|---------|----------|
| [Primary] | [Main actions] |
| [Secondary] | [Supporting actions] |

### Props / Properties
| Property | Type | Default | Description |
|----------|------|---------|-------------|
| [prop] | [type] | [default] | [description] |

### States
| State | Visual | Behavior |
|-------|--------|----------|
| Default | [description] | — |
| Hover | [description] | [interaction] |
| Active | [description] | [interaction] |
| Disabled | [description] | Non-interactive |
| Loading | [description] | [animation] |

### Accessibility
- **Role**: [ARIA role]
- **Keyboard**: [Tab, Enter, Escape behavior]
- **Screen reader**: [Announced as...]

### Do's and Don'ts
| ✅ Do | ❌ Don't |
|------|---------|
| [Best practice] | [Anti-pattern] |

### Code Example
[Framework-appropriate code snippet]

Output — Extend

## New Component: [Name]

### Problem
[What user need or gap this component addresses]

### Existing Patterns
| Related Component | Similarity | Why It's Not Enough |
|-------------------|-----------|---------------------|
| [Component] | [What's shared] | [What's missing] |

### Proposed Design

#### API / Props
| Property | Type | Default | Description |
|----------|------|---------|-------------|
| [prop] | [type] | [default] | [description] |

#### Variants
| Variant | Use When | Visual |
|---------|----------|--------|
| [Variant] | [Scenario] | [Description] |

#### States
| State | Behavior | Notes |
|-------|----------|-------|
| Default | [Description] | — |
| Hover | [Description] | [Interaction] |
| Disabled | [Description] | Non-interactive |
| Loading | [Description] | [Animation] |

#### Tokens Used
- Colors: [Which tokens]
- Spacing: [Which tokens]
- Typography: [Which tokens]

### Accessibility
- **Role**: [ARIA role]
- **Keyboard**: [Expected interactions]
- **Screen reader**: [Announced as...]

### Open Questions
- [Decision that needs design review]
- [Edge case to resolve]

If Connectors Available

If ~~design tool is connected:

  • Audit components directly in Figma — check naming, variants, and token usage
  • Pull component properties and layer structure for documentation

If ~~knowledge base is connected:

  • Search for existing component documentation and usage guidelines
  • Publish updated documentation to your wiki

Tips

  1. Start with an audit — Know where you are before deciding where to go.
  2. Document as you build — It's easier to document a component while designing it.
  3. Prioritize coverage over perfection — 80% of components documented beats 100% of 10 components.