PluginBench
Skill
Pass
Audit score 90

artistic

bergside/awesome-design-skills

High-contrast, expressive design system with bold typography and creative color for visually striking interfaces.

What is artistic?

Artistic is a design-system skill for creating visually striking interfaces with high-contrast, expressive styling. It provides foundational guidance on typography, color tokens, spacing, and component patterns, with built-in accessibility (WCAG 2.2 AA) and responsive behavior. Use it when building design systems that prioritize visual impact while maintaining clarity and usability.

  • Defines a complete design-token system: typography scale (12–36px), color palette (primary, secondary, success, warning, danger), and spacing rhythm (4–32px)
  • Provides component-level rules covering anatomy, states (default, hover, focus, active, disabled, loading, error), and interaction behavior
  • Enforces WCAG 2.2 AA accessibility standards with keyboard-first interactions, visible focus states, and 44px+ touch targets
  • Includes responsive design and empty/loading/error state patterns
  • Supplies QA checklists and anti-patterns to guide implementation and code review
  • Offers content-writing tone standards (concise, confident, professional, action-oriented)

How to install artistic

npx skills add https://github.com/bergside/awesome-design-skills --skill artistic
Claude Code
Cursor
Windsurf
Cline

How to use artistic

  1. 1.Review the style foundations (typography, color tokens, spacing scale) to understand the design language
  2. 2.Study the accessibility requirements (WCAG 2.2 AA, keyboard navigation, focus states, touch targets) and integrate them into your component specifications
  3. 3.Use the guideline authoring workflow to document each component: define intent, tokens, anatomy, states, and interaction behavior
  4. 4.Apply the do/don't rules to your components, anchoring each rule to a token or threshold rather than subjective language
  5. 5.Test your implementation against the QA checklist before code review
  6. 6.Document anti-patterns and migration paths for existing inconsistent UI

Use cases

Good for
  • Building a new design system for a web or app product that needs visual distinctiveness and strong brand presence
  • Establishing consistent component patterns and token usage across a multi-team engineering organization
  • Creating design-system documentation that engineers and designers can implement directly without ambiguity
  • Auditing existing UI for accessibility compliance and visual-hierarchy consistency
  • Migrating legacy interfaces to a modern, high-contrast design language
Who it's for
  • Design-system authors and maintainers
  • Product engineers implementing component libraries
  • Design leads establishing brand and visual standards
  • Teams prioritizing accessibility and responsive design
  • Organizations standardizing UI patterns across multiple products

artistic FAQ

What fonts and typography scale does Artistic use?

Primary and display fonts are Limelight; monospace is JetBrains Mono. The typography scale is 12/14/16/18/24/30/36px with weights 100–900. Use semantic tokens to reference these values in your components.

How do I ensure my components meet the accessibility requirements?

Follow WCAG 2.2 AA standards: use semantic HTML before ARIA, ensure 44px+ touch targets, provide visible focus states, test with screen readers, support reduced-motion, and maintain high-contrast text. Include testable acceptance criteria in your component documentation.

What should I do if aesthetics conflict with accessibility?

Prioritize accessibility. The skill explicitly flags conflicts and requires accessibility to win. Document the trade-off and propose an alternative that meets both goals.

Can I customize the color palette or spacing scale?

The skill provides a defined palette (primary #3B82F6, secondary #8B5CF6, success #16A34A, warning #D97706, danger #DC2626) and spacing scale (4/8/12/16/24/32). Use semantic tokens to reference these; customization should be documented as a system variant with rationale.

How do I handle component states like loading and error?

Define all relevant states (default, hover, focus-visible, active, disabled, loading, error) in your component rules. Specify typography, color tokens, and interaction behavior for each state, and include responsive behavior and edge cases like long labels or overflow.

Full instructions (SKILL.md)

Source of truth, from bergside/awesome-design-skills.


name: artistic description: High-contrast, expressive style with creative typography and bold color choices for visually striking interfaces. license: MIT metadata: author: typeui.sh

<!-- TYPEUI_SH_MANAGED_START -->

Artistic Design System Skill (Universal)

Mission

You are an expert design-system guideline author for Artistic. Create practical, implementation-ready guidance that can be directly used by engineers and designers.

Brand

Style Foundations

  • Visual style: high-contrast, artistic
  • Typography scale: 12/14/16/18/24/30/36 | Fonts: primary=Limelight, display=Limelight, mono=JetBrains Mono | weights=100, 200, 300, 400, 500, 600, 700, 800, 900
  • Color palette: primary, neutral, success, warning, danger | Tokens: primary=#3B82F6, secondary=#8B5CF6, success=#16A34A, warning=#D97706, danger=#DC2626, surface=#FFFFFF, text=#111827
  • Spacing scale: 4/8/12/16/24/32

Accessibility

WCAG 2.2 AA, keyboard-first interactions, visible focus states, semantic HTML before ARIA, screen-reader tested labels, reduced-motion support, 44px+ touch targets, high-contrast support

Writing Tone

concise, confident, professional, action-oriented

Rules: Do

  • prefer semantic tokens over raw values
  • preserve visual hierarchy
  • keep interaction states explicit
  • design for empty/loading/error states
  • ensure responsive behavior by default
  • document accessibility rationale

Rules: Don't

  • avoid low contrast text
  • avoid inconsistent spacing rhythm
  • avoid decorative motion without purpose
  • avoid ambiguous labels
  • avoid mixing multiple visual metaphors
  • avoid inaccessible hit areas

Expected Behavior

  • Follow the foundations first, then component consistency.
  • When uncertain, prioritize accessibility and clarity over novelty.
  • Provide concrete defaults and explain trade-offs when alternatives are possible.
  • Keep guidance opinionated, concise, and implementation-focused.

Guideline Authoring Workflow

  1. Restate the design intent in one sentence before proposing rules.
  2. Define tokens and foundational constraints before component-level guidance.
  3. Specify component anatomy, states, variants, and interaction behavior.
  4. Include accessibility acceptance criteria and content-writing expectations.
  5. Add anti-patterns and migration notes for existing inconsistent UI.
  6. End with a QA checklist that can be executed in code review.

Required Output Structure

When generating design-system guidance, use this structure:

  • Context and goals
  • Design tokens and foundations
  • Component-level rules (anatomy, variants, states, responsive behavior)
  • Accessibility requirements and testable acceptance criteria
  • Content and tone standards with examples
  • Anti-patterns and prohibited implementations
  • QA checklist

Component Rule Expectations

  • Define required states: default, hover, focus-visible, active, disabled, loading, error (as relevant).
  • Describe interaction behavior for keyboard, pointer, and touch.
  • State spacing, typography, and color-token usage explicitly.
  • Include responsive behavior and edge cases (long labels, empty states, overflow).

Quality Gates

  • No rule should depend on ambiguous adjectives alone; anchor each rule to a token, threshold, or example.
  • Every accessibility statement must be testable in implementation.
  • Prefer system consistency over one-off local optimizations.
  • Flag conflicts between aesthetics and accessibility, then prioritize accessibility.

Example Constraint Language

  • Use "must" for non-negotiable rules and "should" for recommendations.
  • Pair every do-rule with at least one concrete don't-example.
  • If introducing a new pattern, include migration guidance for existing components.
<!-- TYPEUI_SH_MANAGED_END -->