PluginBench
Skill
Pass
Audit score 90

sega

bergside/awesome-design-skills

Arcade-inspired design system with pixel typography, chunky buttons, and retro cabinet aesthetics for games.

What is sega?

Sega is a playful, arcade-inspired design system built on the VT323 pixel typeface, hard-edged corners, and chunky pill buttons with offset shadows. Use it when building game interfaces or retro-styled applications that need consistent, accessible component guidance.

  • Provides semantic design tokens (colors, typography scale 13–35px, spacing 4–32px)
  • Defines component anatomy, states, and interaction behavior for arcade-style UI elements
  • Enforces WCAG 2.2 AA accessibility with keyboard-first interactions and visible focus states
  • Includes anti-patterns, QA checklists, and migration guidance for design consistency
  • Specifies responsive behavior and edge-case handling (long labels, overflow, empty states)
  • Offers implementation-ready guidance for engineers and designers with explicit do/don't rules

How to install sega

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

How to use sega

  1. 1.Review the brand foundations: VT323 pixel typeface, 0px corners, chunky pill buttons, and rainbow-ringed shadows
  2. 2.Study the design tokens: typography scale (13/15/17/21/27/35px), color palette (primary=#4502FF, secondary=#FFDA14, etc.), and spacing scale (4/8/12/16/24/32)
  3. 3.Apply component rules by defining required states (default, hover, focus-visible, active, disabled, loading, error)
  4. 4.Implement keyboard-first interactions with visible focus states for accessibility
  5. 5.Use the QA checklist to validate component implementation in code review
  6. 6.Reference anti-patterns and migration notes when updating existing UI

Use cases

Good for
  • Building a retro arcade game interface with consistent button and card styling
  • Creating a game dashboard or menu system that follows pixel-art and cabinet-trim aesthetics
  • Establishing design-system guidelines for a team working on multiple game UI screens
  • Migrating existing inconsistent game UI to a unified, accessible design language
  • Designing accessible game controls and navigation with keyboard-first interaction patterns
Who it's for
  • Game UI/UX designers
  • Frontend engineers implementing game interfaces
  • Design-system maintainers and design leads
  • Teams building retro or arcade-themed applications

sega FAQ

What typefaces does Sega use?

Primary and display use VT323 (pixel typeface), with JetBrains Mono for monospace. All weights from 100–900 are supported.

What accessibility standard does Sega follow?

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

How do I handle long labels or overflow in Sega components?

The guidance includes explicit rules for responsive behavior and edge cases; refer to the component-level rules section for spacing, typography, and overflow handling.

Can I use Sega for non-game applications?

Sega is designed for arcade-inspired game interfaces, but its design-system structure and accessibility rules can be adapted for other retro or playful UI contexts.

What should I do if I have existing UI that doesn't match Sega?

The skill includes anti-patterns and migration notes to help you incrementally update inconsistent components to align with the system.

Full instructions (SKILL.md)

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


name: "sega" description: "A playful, arcade-inspired interface for games — built on the VT323 pixel typeface, hard-edged 0px corners, chunky pill buttons that physically press into solid offset blocks" metadata: author: typeui.sh

<!-- TYPEUI_SH_MANAGED_START -->

Sega Design System Skill (Universal)

Mission

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

Brand

A playful, arcade-inspired interface for games — built on the VT323 pixel typeface, hard-edged 0px corners, chunky pill buttons that physically press into solid offset blocks, and cards wrapped in rainbow-ringed brand shadows that read like cabinet trim.

Style Foundations

  • Visual style: modern, playful
  • Typography scale: 13/15/17/21/27/35 | Fonts: primary=VT323, display=VT323, mono=JetBrains Mono | weights=100, 200, 300, 400, 500, 600, 700, 800, 900
  • Color palette: primary, secondary, neutral, success, warning, danger | Tokens: primary=#4502FF, secondary=#FFDA14, 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 -->