PluginBench
Skill
Pass
Audit score 90

tetris

bergside/awesome-design-skills

Tetris-inspired design system with playful colors, bold fonts, and high-energy compact layouts.

What is tetris?

A design-system skill that applies classic Tetris visual aesthetics—high-contrast, playful premium style—to UI design. Use it when building interfaces that need energetic, game-inspired branding with semantic tokens, accessibility-first interactions, and consistent component guidance.

  • Provides design tokens (colors, typography, spacing) based on Tetris visual identity
  • Defines component anatomy, states, and interaction behavior for consistent UI
  • Enforces WCAG 2.2 AA accessibility with keyboard-first interactions and visible focus states
  • Offers implementation-ready guidance for engineers and designers
  • Includes QA checklists and anti-pattern documentation for code review

How to install tetris

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

How to use tetris

  1. 1.Review the design tokens (colors, typography, spacing scale) and integrate them into your codebase
  2. 2.Define component anatomy and required states (default, hover, focus, active, disabled, loading, error)
  3. 3.Apply semantic tokens over raw values in all component implementations
  4. 4.Test keyboard navigation and focus-visible states for accessibility compliance
  5. 5.Use the QA checklist during code review to validate consistency and accessibility

Use cases

Good for
  • Building a playful, high-energy web or app interface with Tetris branding
  • Creating a design-system guideline document for a team working on a game-inspired product
  • Establishing consistent component rules (buttons, forms, layouts) across a codebase
  • Ensuring accessibility compliance while maintaining bold, expressive visual style
  • Migrating existing inconsistent UI to a unified Tetris-inspired design language
Who it's for
  • Design-system authors and maintainers
  • UI/UX designers working on playful or game-inspired products
  • Frontend engineers implementing design tokens and components
  • Product teams building accessible, branded interfaces

tetris FAQ

What fonts does this design system use?

Primary and display fonts use Bangers; monospace uses JetBrains Mono. All weights from 100 to 900 are supported.

Does this system include responsive behavior guidance?

Yes. The skill defines component-level rules including responsive behavior and edge cases like long labels and overflow handling.

How do I ensure accessibility compliance?

Follow WCAG 2.2 AA standards, use keyboard-first interactions, maintain visible focus states, and avoid low-contrast text. The skill includes testable acceptance criteria.

Can I use this for non-game products?

Yes. While inspired by Tetris aesthetics, the design system is universal and can be applied to any product needing playful, high-contrast, premium branding.

What should I do if I find conflicting rules between aesthetics and accessibility?

Always prioritize accessibility. The skill explicitly flags such conflicts and provides guidance to resolve them in favor of clarity and compliance.

Full instructions (SKILL.md)

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


name: tetris description: Classic block-game inspired design with playful colors, bold display fonts, and compact, high-energy layouts. license: MIT metadata: author: typeui.sh

<!-- TYPEUI_SH_MANAGED_START -->

Tetris Design System Skill (Universal)

Mission

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

Brand

the most iconic game of history

Style Foundations

  • Visual style: high-contrast, playful, premium
  • Typography scale: desktop-first expressive scale | Fonts: primary=Bangers, display=Bangers, mono=JetBrains Mono | weights=100, 200, 300, 400, 500, 600, 700, 800, 900
  • Color palette: primary, secondary, success, warning, danger, info | Tokens: primary=#1C202B, secondary=#7107E7, success=#16A34A, warning=#D97706, danger=#DC2626, surface=#DFE7FF, text=#1C398E
  • Spacing scale: compact density mode

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