plugins/game-dev/skills/player-ux/SKILL.md
Cognitive load management for players: perception/attention/memory framework, Gestalt principles for game UI, signal-noise discipline on the HUD, onboarding ramp design, and tooltip/affordance patterns. Use when designing UI or HUD layouts, writing tutorials or first-time-user flows, evaluating whether players can read the screen at a glance, debugging 'confusing' feedback, deciding what information goes where (HUD, pause, codex, none), or when playtesters say 'I didn't know I could do that' or 'I missed that this happened.' For deeper accessibility work see accessibility-design.
npx skillsauth add rbergman/dark-matter-marketplace player-uxInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
Purpose: Apply cognitive science to game interface and interaction design. The player's brain has hard constraints — limited attention, lossy perception, fragile memory. Design with those constraints, not against them.
Influences: Frameworks here draw on neuroscience-grounded game UX research, with supporting concepts from experience engineering theory (elegance, attention budgets) and established perceptual psychology (Gestalt principles, cognitive load theory).
Use this skill when:
Every interaction between player and game passes through three systems, in order:
Perception → Attention → Memory
(Did they see it?) → (Did they focus on it?) → (Will they remember it?)
If any pillar fails, everything downstream fails too.
The brain doesn't passively receive information — it actively constructs a model based on expectations, context, and sensory input. Perception is top-down: what you know influences what you see.
Gestalt Principles for Game UI:
| Principle | Rule | Game Application | |-----------|------|------------------| | Proximity | Near objects are perceived as grouped | Group related HUD elements spatially (health + shield together) | | Similarity | Similar appearance = perceived as related | Use consistent color/shape for same-category items | | Figure-Ground | Salient elements pop out from background | Critical info needs contrast against the game world | | Continuity | The eye follows smooth paths | Guide attention with visual flow (menu layouts, tutorials) | | Closure | The brain completes incomplete shapes | Progress bars, partially-revealed maps work because of this |
Perception Checklist:
Attention is a finite resource. The brain consumes ~20% of body energy at ~2% of body weight. Every UI element, tutorial popup, and status indicator competes for this budget.
The Core Pillars Method:
The Green Ball Anti-Pattern: "Playing golf with a green ball on a green course" — when the challenge is finding the thing rather than doing the thing, you've put the difficulty in the wrong place. The challenge should be the experience, not a barrier to reaching it.
Attention Audit:
Working memory holds ~4 chunks simultaneously. Long-term encoding requires emotional significance, repetition, or active processing. Tutorials that dump information before the player has context to encode it are wasted.
Memory-Friendly Design:
Memory Audit:
Two distinct UX goals that are often confused:
| Dimension | Question | When It Fails | |-----------|----------|---------------| | Usability | Can the player do what they intend? | Player blames themselves: "I'm bad at this" | | Engage-ability | Does the player want to keep playing? | Player blames the game: "This is boring" |
Critical insight: Usability problems masquerade as difficulty problems. Players blame their own skill when the real issue is bad UI. Test usability before tuning difficulty.
Phase 1: Safe exploration (no failure possible)
→ Introduce movement and core interaction
→ Let the player touch things without consequence
Phase 2: Guided challenge (gentle failure)
→ Introduce the core mechanic with clear success/failure
→ Immediate feedback on what went wrong
Phase 3: Supported mastery (real challenge, safety nets)
→ Full mechanics, but with hints available
→ Coyote time, generous hit windows, undo options
Phase 4: Release (full game)
→ Remove scaffolding gradually
→ Player should feel competent, not coddled
You have played your game for hundreds of hours. Your players have played for zero. This asymmetry is the single biggest UX risk in game development.
Counter-measures:
| Category | Minimum Standard | |----------|-----------------| | Vision | No info conveyed by color alone; support colorblind modes (~10% of players) | | Contrast | Critical UI elements meet 4.5:1 contrast ratio against background | | Motor | Rebindable controls; no rapid-press requirements without alternatives | | Cognitive | Difficulty options; pausable gameplay; adjustable text speed | | Redundancy | Critical feedback uses 2+ channels (visual + audio minimum) |
Complexity is finite. Spend it on your core experience.
Total complexity budget
├── Core loop complexity (SPEND HERE — this IS the game)
├── Secondary systems (keep lean — inventory, menus, settings)
├── Onboarding complexity (minimize — teach through play)
└── Meta-game complexity (justify every layer)
Rule of thumb: If a system isn't part of the core loop, it should require less than 1 minute of learning. If it requires more, either it should be a core pillar or it needs simplification.
development
Initialize a new repository with standard scaffolding - git, gitignore, AGENTS.md, justfile, mise, beads, and timbers. Use when starting a new project or setting up an existing repo for Claude Code workflows.
data-ai
Activate at session start when using Agent Teams for complex multi-agent work. Establishes team lead role with delegation protocols, teammate spawning, model selection, and beads integration. You coordinate the team; teammates implement.
data-ai
Use when creating a worktree, setting up a worktree, starting feature work that needs isolation, or before executing implementation plans. Covers git worktree creation under .worktrees/, gitignore setup, beads integration, and merge guardrails.
data-ai
Activate when you are a delegated subagent (not the orchestrator). Establishes subagent protocol with terse returns, details to history/, file ownership boundaries, and escalation rules. You implement; orchestrator reviews and commits.