
Design System Creation
- 489 installs
- 305 repo stars
- Updated March 4, 2026
- aj-geddes/useful-ai-prompts
design-system-creation is a design system generator skill that produces tokens, components, patterns, and documentation for developers who need consistent UI foundations across multiple product interfaces.
About
design-system-creation is a Design & UI/UX skill from aj-geddes/useful-ai-prompts that builds comprehensive design systems with components, patterns, and guidelines to keep interfaces consistent as products scale. The overview defines a design system as a structured set of components, principles, and rules that accelerate development and improve quality, and the when-to-use section cites multiple product interfaces, scaling design consistency, and reducing redundant UI work. A developer reaches for design-system-creation when bootstrapping token sets, component specs, usage patterns, and documentation for React, Vue, or other frontend stacks. The skill includes quick start, reference guides, and best practices sections for repeatable system authoring.
- Creates foundation layer with typography scales, color palettes including dark mode, and spacing grids
- Defines shadows, elevation, motion and iconography standards
- Produces reusable component specifications and usage guidelines
- Generates design tokens exportable to code and documentation
- Establishes shared language that improves design-to-dev handoff
Design System Creation by the numbers
- 489 all-time installs (skills.sh)
- Ranked #601 of 1,880 Design & UI/UX skills by installs in the Skillselion catalog
- Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/aj-geddes/useful-ai-prompts --skill design-system-creationAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 489 |
|---|---|
| repo stars | ★ 305 |
| Last updated | March 4, 2026 |
| Repository | aj-geddes/useful-ai-prompts ↗ |
How do you generate a design system with tokens and components?
Generate complete, reusable design systems with tokens, components, patterns and documentation that keep UIs consistent across growing products.
Who is it for?
Frontend developers scaling multiple interfaces who need agent-guided design tokens, components, and pattern documentation from scratch.
Skip if: Developers tweaking a single page or working inside an established enterprise design system with no new tokens needed should skip design-system-creation.
When should I use this skill?
A user asks to create or expand a design system with tokens, components, patterns, or cross-product UI consistency guidelines.
What you get
Design token definitions, component library specs, UI pattern guidelines, and design system documentation.
- design tokens
- component specs
- pattern documentation
Files
Design System Creation
Table of Contents
Overview
A design system is a structured set of components, guidelines, and principles that ensure consistency, accelerate development, and improve product quality.
When to Use
- Multiple product interfaces or teams
- Scaling design consistency
- Reducing redundant component development
- Improving design-to-dev handoff
- Creating shared language across teams
- Building reusable components
- Documenting design standards
Quick Start
Minimal working example:
Design System Structure:
Foundation Layer:
Typography:
- Typefaces (Roboto, Inter)
- Font sizes (scale: 12, 14, 16, 20, 28, 36, 48)
- Font weights (Regular, Medium, Bold)
- Line heights and letter spacing
Colors:
- Primary brand color (#2196F3)
- Secondary colors
- Neutral palette (grays)
- Semantic colors (success, error, warning)
- Dark mode variants
Spacing:
- Base unit: 4px
- Scale: 4, 8, 12, 16, 24, 32, 48, 64px
- Apply consistently across UI
Shadows & Elevation:
- Elevation 0 (flat)
- Elevation 1, 2, 4, 8, 16 (increasing depth)
- Used for modals, cards, overlays
// ... (see reference guides for full implementation)Reference Guides
Detailed implementations in the references/ directory:
| Guide | Contents |
|---|---|
| Design System Components | Design System Components |
| Component Documentation | Component Documentation |
| Design System Governance | Design System Governance |
| Design System Documentation | Design System Documentation |
Best Practices
✅ DO
- Start with essential components
- Document every component thoroughly
- Include code examples
- Test components across browsers
- Include accessibility guidance
- Version the design system
- Have clear governance
- Communicate updates proactively
- Gather feedback from users
- Maintain incrementally
❌ DON'T
- Create too many components initially
- Skip documentation
- Ignore accessibility
- Make breaking changes without migration path
- Allow inconsistent implementations
- Ignore user feedback
- Let design system stagnate
- Create components without proven need
- Make components too prescriptive
- Ignore performance impact
Component Documentation
Component Documentation
# Document each component thoroughly
class ComponentDocumentation:
def create_component_doc(self, component):
"""Document complete component"""
return {
'name': component.name,
'description': component.description,
'usage': component.when_to_use,
'anatomy': {
'elements': component.sub_elements,
'diagram': 'Show with labels'
},
'properties': {
'size': ['Small', 'Medium', 'Large'],
'variant': component.variants,
'state': ['Default', 'Hover', 'Focus', 'Disabled'],
'disabled': True/False,
'required': True/False
},
'code_examples': [
'React example',
'CSS example',
'HTML example'
],
'accessibility': {
'aria_roles': component.aria_roles,
'keyboard_support': component.keyboard_behavior,
'screen_reader': component.sr_text
},
'do_dont': {
'do': ['Guideline 1', 'Guideline 2'],
'dont': ['Guideline 1', 'Guideline 2']
}
}
def create_live_component_library(self):
"""Build interactive component showcase"""
return {
'tool': 'Storybook / Zeroheight',
'features': [
'Live component preview',
'Interactive controls',
'Code examples',
'Documentation',
'Version history'
],
'coverage': 'All components with all variants'
}Design System Components
Design System Components
Design System Structure:
Foundation Layer:
Typography:
- Typefaces (Roboto, Inter)
- Font sizes (scale: 12, 14, 16, 20, 28, 36, 48)
- Font weights (Regular, Medium, Bold)
- Line heights and letter spacing
Colors:
- Primary brand color (#2196F3)
- Secondary colors
- Neutral palette (grays)
- Semantic colors (success, error, warning)
- Dark mode variants
Spacing:
- Base unit: 4px
- Scale: 4, 8, 12, 16, 24, 32, 48, 64px
- Apply consistently across UI
Shadows & Elevation:
- Elevation 0 (flat)
- Elevation 1, 2, 4, 8, 16 (increasing depth)
- Used for modals, cards, overlays
---
Component Layer:
Basic Components:
- Button (primary, secondary, outline, disabled states)
- Input fields (text, password, number, email)
- Dropdown / Select
- Checkbox & Radio buttons
- Toggle switch
- Textarea
Form Components:
- Form group (label + input + error)
- Error messages
- Help text
- Required indicators
- Validation states
Navigation:
- Breadcrumbs
- Tabs
- Navigation drawer
- Pagination
- Stepper
Feedback:
- Toast notifications
- Modal dialogs
- Alerts
- Loading indicators
- Progress bars
Data Display:
- Tables
- Lists
- Cards
- Badges
- Chips
---
Pattern Layer:
Layout Patterns:
- Main layout (header + nav + content + footer)
- Two-column (main + sidebar)
- Form layouts
- Grid layouts
Content Patterns:
- Empty states
- Loading states
- Error states
- Confirmation dialogs
- Onboarding flows
Interaction Patterns:
- Hover states
- Focus states
- Disabled states
- Transitions/animations
- Keyboard navigationDesign System Documentation
Design System Documentation
Documentation Structure:
Getting Started:
- What is the design system?
- How to use in your project
- Installation instructions
- Quick start guide
Foundations:
- Color system
- Typography scale
- Spacing/grid system
- Icons
- Accessibility standards
Components:
- [Detailed component docs]
Patterns:
- Common layouts
- Content patterns
- Interaction patterns
- Form patterns
Guidelines:
- Voice & tone
- Imagery & photography
- Brand identity
- Copy guidelines
Use Cases:
- Real-world examples
- Case studies
- Do's and don'ts
Updates:
- Release notes
- Migration guides
- Roadmap
- Contribution processDesign System Governance
Design System Governance
Design System Governance:
Ownership:
Owner: Design System Lead
Committee: 1 Designer, 1 Developer, 1 Product Manager
Review Frequency: Biweekly
Approval Process: Committee sign-off required
Component Lifecycle:
Proposed:
- Submitted by team
- Reviewed for duplication
- Assessed for scope
In Review:
- Design review
- Accessibility audit
- Developer implementation review
- 1-2 week review period
Approved:
- Documented in system
- Available in component library
- Semver version bump
- Teams notified
Deprecated:
- Clear timeline for migration
- Updated component provided
- Support period: 2 major versions
Retired:
- Removed from library
- Historical documentation archived
---
Contribution Guidelines:
To Add Component: 1. Check existing components
2. Submit RFC (Request for Comments)
3. Attend design review
4. Implement per standards
5. Get committee approval
6. Document in library
7. Release in new version
Standards:
- Accessibility (WCAG 2.1 AA minimum)
- Mobile-first responsive design
- Dark mode support
- Internationalization (i18n)
- Performance (<100kb added to bundle)// Component: [Name]
// TODO: Customize for your framework (React, Vue, Svelte, etc.)
import React from 'react';
interface Props {
// TODO: Define props
}
export function ComponentName({ }: Props) {
// TODO: Add state and effects
return (
<div>
{/* TODO: Add component markup */}
</div>
);
}
Related skills
FAQ
What does design-system-creation produce?
design-system-creation builds components, patterns, guidelines, and documentation so teams maintain consistent design tokens and reusable UI specs across growing products.
When should you use design-system-creation?
design-system-creation fits multiple product interfaces, scaling design consistency, and reducing redundant UI implementation work according to its when-to-use guidance.
Is design-system-creation only for designers?
design-system-creation targets developers and designers collaborating on structured component libraries, tokens, and principles that accelerate frontend implementation.