PluginBench
Skill
Pass
Audit score 90

brutalism

bergside/awesome-design-skills

Raw, anti-design aesthetic system inspired by concrete architecture with unadorned elements and functional minimalism.

What is brutalism?

Brutalism is a design-system skill for creating bold, anti-design interfaces inspired by 1950s raw concrete architecture. Use it when you want to prioritize functional, unadorned aesthetics over polished conventional design while maintaining WCAG 2.2 AA accessibility.

  • Define design tokens (colors, typography, spacing) with semantic naming and explicit constraints
  • Create component-level rules specifying anatomy, states, variants, and interaction behavior
  • Establish accessibility requirements including keyboard-first interactions and visible focus states
  • Document content and tone standards with concrete examples and anti-patterns
  • Provide QA checklists and migration guidance for consistent implementation
  • Prioritize accessibility over novelty with testable acceptance criteria

How to install brutalism

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

How to use brutalism

  1. 1.Restate the design intent in one sentence before proposing any rules
  2. 2.Define tokens and foundational constraints (colors, typography, spacing) before component guidance
  3. 3.Specify component anatomy, states, variants, and interaction behavior for each element
  4. 4.Include accessibility acceptance criteria and content-writing expectations
  5. 5.Document anti-patterns and migration notes for existing inconsistent UI
  6. 6.Execute the QA checklist during code review to verify consistency

Use cases

Good for
  • Building a design system for a bold, anti-design brand that rejects polished conventions
  • Creating component guidelines with explicit state definitions (default, hover, focus, active, disabled, loading, error)
  • Establishing accessibility-first design rules that pass WCAG 2.2 AA while maintaining jarring, functional aesthetics
  • Documenting design tokens and foundational constraints before implementing individual components
  • Reviewing code against a design-system QA checklist to ensure consistency
Who it's for
  • Design system authors and maintainers
  • Frontend engineers implementing brutalist design systems
  • Product designers defining bold, anti-design aesthetics
  • Teams prioritizing accessibility and functional clarity over conventional polish

brutalism FAQ

What is the Brutalism design system?

A bold, anti-design style inspired by 1950s raw concrete architecture that prioritizes functional, unadorned, and often jarring aesthetics over polished, conventional design.

What accessibility standard does Brutalism follow?

WCAG 2.2 AA with keyboard-first interactions, visible focus states, and no low-contrast text.

What are the core design tokens in Brutalism?

Primary color #DD614C, secondary #DAA144, success #16A34A, warning #D97706, danger #DC2626, with Darker Grotesque for typography and a 4/8/12/16/24/32 spacing scale.

How should I handle conflicts between aesthetics and accessibility?

Always prioritize accessibility; flag the conflict and explain the trade-off in your guidance.

What should a component rule include?

Required states (default, hover, focus-visible, active, disabled, loading, error), interaction behavior for keyboard/pointer/touch, spacing/typography/color usage, and responsive behavior.

Full instructions (SKILL.md)

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


name: brutalism description: Raw, anti-design aesthetic inspired by concrete architecture with unadorned elements, jarring layouts, and functional minimalism. license: MIT metadata: author: typeui.sh

<!-- TYPEUI_SH_MANAGED_START -->

Brutalism Design System Skill (Universal)

Mission

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

Brand

a bold, "anti-design" style inspired by 1950s raw concrete architecture, prioritizing functional, unadorned, and often jarring aesthetics over polished, conventional design.

Style Foundations

  • Visual style: bold
  • Typography scale: desktop-first expressive scale | Fonts: primary=Darker Grotesque, display=Darker Grotesque, mono=JetBrains Mono | weights=100, 200, 300, 400, 500, 600, 700, 800, 900
  • Color palette: primary, secondary, neutral, success, warning, danger | Tokens: primary=#DD614C, secondary=#DAA144, 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

Writing Tone

concise, confident, helpful

Rules: Do

  • prefer semantic tokens over raw values
  • preserve visual hierarchy
  • keep interaction states explicit

Rules: Don't

  • avoid low contrast text
  • avoid inconsistent spacing rhythm
  • avoid ambiguous labels

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 -->