rbergman
50 verified skills178 total stars
lead
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-ai5
repo-init
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.
development5
review
Collaborative code review using Agent Teams where reviewers discuss findings, challenge each other, and converge on a unified assessment. Evolves dm-work:review from isolated parallel reviewers to a review team.
development4
repo-health
Analyze a repository's configuration against CC and workflow best practices. Use when auditing a repo, after repo-init, or when troubleshooting token usage or workflow gaps. Reports issues by severity with auto-fix offers.
testing4
orchestrator
Activate at session start when you are the primary Claude instance. Establishes orchestrator role with delegation protocols, subagent launch templates, token efficiency rules, and parallel safety constraints. You orchestrate; subagents implement.
testing4
worktrees
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-ai4
experience-design
Engagement loop design, pacing frameworks, the Experience Triangle (mechanics + dynamics + aesthetics), emotion layering across a session, and evaluating whether choices feel meaningful. Use when designing the core loop, structuring an emotional arc across 5-30 min sessions, debugging 'feels flat' or 'feels samey' play, evaluating whether decisions matter, planning peaks and valleys of intensity, or when playtesters describe sessions as 'fine but forgettable.' Sits one level above game-design (mechanic-level) and one below game-vision (north-star-level).
development4
game-balance
Numeric balance across game objects with stats — cost curves, transitive vs intransitive systems, dominant strategy detection, sandbagging signals, and anti-degenerate-strategy levers. Use when designing item or weapon stats, pricing storefronts, combat damage/HP/range numbers, upgrade trees, character classes, faction asymmetry, or anywhere two objects have numeric attributes that should relate fairly. Apply when playtesters say 'X is just better,' 'one path always wins,' or 'I never use Y.' Pairs with economy-design (currency flow) and progression-systems (curves over time).
testing4
game-feel
Juice, feedback layering, screen shake/particles/sound timing, the perception-action cycle, and 'why does this feel bad?' diagnostics. Use when implementing player actions, combat hits, collectibles, UI transitions, weapon impacts, jumps, dashes, or any moment where the player should *feel* something; when a mechanic functionally works but feels mushy, slow, or unsatisfying; or when playtesters say 'it's missing something.' Covers timing reference numbers (frames per response phase), feedback channels (visual/audio/haptic/screen), and the diagnostic ladder for feel problems.
testing4
game-perf
Per-frame performance and GC-pressure optimization for JS/TS game code. Use when editing game loops, update functions, render passes, physics steps, particle systems, or any code that runs every frame; when diagnosing jank, frame drops, or stuttering; when allocations show up in flame graphs; or when the user mentions frame budget, hot paths, or 'feels janky'. Identifies common allocation anti-patterns (spread in loops, .map/.filter chains in update, closures captured per frame) and provides pooled / pre-allocated alternatives.
development4
progression-systems
Difficulty curves, flow-channel targeting, power-curve math, unlock pacing, reward scheduling, XP/level formulas, and prestige/new-game-plus loops. Use when designing level-up or progression systems, tuning a difficulty ramp, deciding when to unlock content or abilities, implementing adaptive difficulty, choosing between linear/quadratic/exponential curves, or when players report 'too easy,' 'too hard,' 'grindy,' or 'plateaus too long.' For the psychology of why progression motivates see motivation-design; for stat balance between simultaneously-available items see game-balance.
testing4
go-pro
Idiomatic Go with proper error handling, concurrency patterns, slog, generics, and clean package design. Use when implementing, debugging, refactoring, or reviewing Go code; designing package boundaries; resolving race conditions or goroutine leaks; setting up table-driven tests; choosing between channels and mutexes; or tuning module layout. Applies to any Go work unless a more specific role overrides.
development4
just-pro
Patterns for setting up just (command runner) in projects. Use when creating build systems, setting up new repos, organizing build/test/lint recipes, or when the user asks about just/justfile configuration. Covers both simple single-project repos and monorepos with hierarchical justfile modules, mise integration, and conventional recipe naming (check, build, test, lint, fmt).
development4
plugins/language-pro/skills/rust-pro
--- name: rust-pro description: "Boring Rust" — clone freely, prefer for loops over iterator chains, strict lints, ownership-honest code that compiles and reads cleanly. Use when implementing, debugging, refactoring, or reviewing Rust code; resolving borrow checker errors; tuning Cargo lints; choosing between Arc/Rc/Box; designing trait boundaries; or evaluating whether a clone is the right call. Applies to any Rust work unless a more specific role overrides. --- # Rust Pro Senior-level Rust e
tools4
python-pro
Modern Python with uv, ruff, pyright, strict typing, and clean module design. Use when implementing, debugging, refactoring, or reviewing Python code; designing module boundaries; setting up Python projects; resolving type errors; tightening pyproject.toml; choosing between dataclasses and Pydantic; or working with async code, pytest, or packaging. Applies to any Python work unless a more specific role overrides.
development4
typescript-pro
Strict TypeScript with zero-any tolerance, no-unsafe-* lints, floating-promise prevention, and disciplined type-system usage. Use when implementing, debugging, refactoring, or reviewing TypeScript code; resolving type errors; configuring tsconfig/ESLint/Prettier; setting up React/Next/Express patterns; eliminating any/unknown drift; or evaluating advanced generics, conditional types, and inference. Applies to any TypeScript work unless a more specific role overrides.
development4
pixi-vector-arcade
Bootstrap browser-based games with PixiJS 8 and a modern retro/vector aesthetic (Geometry Wars, Asteroids, Tempest, Tron). Use when creating a new game, starting a browser game project, building an arcade game, prototyping a game, setting up PixiJS, or when the user mentions vector graphics, neon aesthetics, or arcade-style gameplay. Provides project scaffolding, ECS-lite architecture, performance patterns (pooling, spatial hashing, fixed timestep), and visual design system.
development4
player-ux
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.
tools4
output-compression
Reduce CLI output noise before it reaches LLM context. Use when setting up repos, troubleshooting context overflow from build/test/git output, or when Bash tool output exceeds limits. Covers RTK (zero-config baseline) and tokf (per-project customization). Either or both may be installed — the skill adapts gracefully when one is absent.
tools4
mise
Dev-tool and runtime version management with mise — the modern replacement for nvm, pyenv, goenv, rbenv, and asdf. Use when setting up a new repo, pinning Node/Python/Go/Rust/Bun versions, configuring per-project tool versions via .mise.toml or .tool-versions, wiring direnv-style env loading, debugging "wrong version active" errors, or migrating off legacy version managers. Covers mise.toml schema, env hooks, task definitions, and integration with just and CI.
tools4
cli-tools
Power CLI tools (fd, rg, jq, yq, sd, xargs, bat, delta) for when built-in tools fall short. Use when searching across many files, transforming JSON/YAML, doing structural search-and-replace, fanning work out in parallel, diffing across history, or chaining commands that would be awkward with grep/find/sed alone. Covers safe defaults (--null/-0 for paths with spaces, jq error handling, fd vs find performance), composition idioms (rg → fd → xargs pipelines), and when each tool is faster or clearer than the POSIX equivalent.
tools4
session-retro
Use at end of session before committing, when landing the plane, or when user says "retro", "what did we learn", "session review". Lightweight self-improvement pass that turns session friction into persistent rules and memories. Runs inline — no separate documents, no approval prompts.
documentation4
accessibility-design
Use when designing any player-facing feature, evaluating a game for accessibility, responding to accessibility feedback, designing difficulty or assist options, adding subtitle/caption systems, implementing input remapping, or when a player reports they can't play. Covers the four accessibility pillars (visual, auditory, motor, cognitive), implementation tiers, colorblind design, subtitle standards, input accessibility, and testing methodology. Accessibility is a design discipline, not a post-launch checklist.
testing4
game-design
The mechanic-level evaluation toolkit — apply the 5-Component Framework (Clarity, Motivation, Response, Satisfaction, Fit) to any individual mechanic. Use when designing or evaluating a single mechanic, reviewing whether a feature pulls its weight, debugging why a specific action feels off, comparing alternative implementations of the same mechanic, or doing a first-pass critique on a player-facing feature. For session-level pacing or emotional arcs see experience-design; for moment-to-moment juice see game-feel; for system-of-systems interactions see systems-design. This skill is the per-mechanic lens.
tools4
council
Multi-perspective deliberation using Agent Teams. Spawn 3-5 teammates with different viewpoints and optionally different models to debate decisions, evaluate specs, or explore trade-offs. Inspired by karpathy/llm-council.
testing4
subagent
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.
data-ai4
economy-design
Resource flow architecture, currency system design, inflation/deflation diagnosis, sink/source balancing, crafting economies, LiveOps event budgeting, and economy simulation modeling. Use when designing resource systems from scratch, adding currencies or stores, setting crafting costs or reward magnitudes, diagnosing inflation or wealth stratification, planning monetization, designing LiveOps events, or when veteran players stockpile while new players feel locked out. Goes deeper than game-balance's economy health check — this is the architectural skill for building and sustaining entire economic systems.
development3
systems-design
System interaction architecture, emergence analysis, coupling evaluation, and possibility space design. Use when designing a new game's system architecture, adding a system to an existing game, evaluating system health, diagnosing 'why doesn't this feel deep?', or when a game has many features but no emergent depth. The central structural skill — bridges individual mechanic evaluation (game-design) with architectural questions about how systems interact to create depth.
content-media3
brainstorm
Multi-perspective brainstorming using Agent Teams. Spawn 2-3 teammates with different analytical angles who explore a design space simultaneously while the human observes and steers via the lead. Falls back to dm-work:brainstorming for simpler design work.
data-ai3
brainstorming
Use when the user wants to explore approaches or discuss design before implementation. Explores intent, requirements, and design through collaborative dialogue.
data-ai3
browser-qa
QA web applications using Chrome DevTools MCP. Use when testing running apps, verifying acceptance criteria against a live UI, checking for console errors, evaluating UI behavior, or running regression checks. Requires the chrome-devtools MCP server to be connected. Complements dm-work:review (code-level) with runtime verification.
tools3
compositions
Reusable team composition templates for common multi-agent workflows. Includes templates for research, review, refinement, implementation, and council teams, plus beads-teams bridge patterns.
testing3
data-driven-design
Use when setting up game analytics, designing telemetry events, interpreting player behavior data, running A/B tests, building dashboards, or making design decisions informed by metrics. Activate for any work involving retention analysis, funnel optimization, cohort comparison, economy health monitoring, or live ops data pipelines. Covers the full data lifecycle from instrumentation through interpretation. Essential for live-service games but valuable for any game that ships updates. Bridges structured playtesting (qualitative observation) with ongoing quantitative measurement. Emphasizes data-informed design over purely data-driven optimization — metrics reveal what is happening, but design judgment determines why and what to do about it.
development3
data-oriented-architecture
Apply when encountering switch/if-else dispatch on entity type, designing entity systems, or refactoring toward extensibility. Provides registry-based dispatch, capability composition, and infrastructure-first patterns. Complements solid-architecture.
development3
game-vision
Use when starting a new game project, pivoting a concept, evaluating whether an idea is worth building, or when prototyping has stalled without clarity. Provides a layered Vision Stack for going from raw concept to validated, structured design. Use BEFORE other game design skills — this is the upstream skill that establishes core fantasy, experience pillars, and core loop so that downstream skills (game-design, experience-design, systems-design, game-balance) have a clear target to work toward. Also use when a team cannot agree on what the game IS, or when scope keeps expanding without a north star.
development3
motivation-design
Player motivation psychology, reward scheduling, intrinsic vs. extrinsic drives, Self-Determination Theory, loss aversion, collection drives, social motivation, and ethical guardrails. Use when designing reward systems, diagnosing why players aren't returning, building achievement or social features, evaluating retention mechanics, or when players say 'I don't know why I'd keep playing.' Bridges the gap between progression math (see progression-systems) and the psychology of why players stay.
development3
playtest-design
Question generation for playtests, what to observe vs. ask, metrics to track, and how to interpret playtest data without confirmation bias. Use when planning a playtest session, designing a feedback survey, setting up analytics, or when you have playtest data and need to make decisions from it.
testing3
audio-design
Use when designing how audio communicates game state, creates emotion, and serves as a feedback system. Activate for sound effect design, adaptive music systems, spatial audio, ambient soundscapes, audio priority and ducking, emotional audio design, and audio accessibility. Also activate when audio feels disconnected from gameplay, when players routinely play on mute (a design failure signal), when evaluating whether the audio stack has appropriate layering and variation, or when planning how music responds to gameplay context. This skill treats audio as a design system — not audio engineering or production, but the intentional design of what players hear, when, and why. Covers the full audio stack from music and ambience through sound effects, UI audio, and voice.
data-ai3
multiplayer-design
Multiplayer game design across cooperative, competitive, asymmetric, social, and asynchronous modes. Matchmaking algorithms, ranked ladder design, anti-toxicity systems, shared economies, team composition, spectator readability, and community health. Use when designing PvP or co-op modes, building matchmaking or ranking systems, designing guilds or social features, planning shared economies or trading, evaluating spectator clarity, handling toxicity as a design problem, designing asynchronous competition, or when players say 'matchmaking is unfair' or 'the community is toxic.' This is the design skill for multiplayer systems — for networking implementation, use engineering resources instead.
development3
refinement
Transform ambiguous specs into implementable work items through live adversarial debate using Agent Teams. Evolves dm-work:dialectical-refinement from sequential pipeline to simultaneous multi-agent debate. Use for l/xl complexity tasks.
devops3
tiered-delegation
Decision framework for when to use Agent Teams vs Task() subagents vs single-session work. Use when facing delegation decisions to choose the right coordination mechanism.
development3
dialectical-refinement
Transform ambiguous specs into implementable work items through adversarial refinement. Use when receiving specs, claiming epics, or starting complex (l/xl) tasks. Use /breakdown for spec→tasks decomposition, /refine for sharpening individual items.
data-ai3
tdd
Use when implementing features or fixing bugs — write the test first, watch it fail, write minimal code to pass. Ensures tests verify behavior by requiring failure first.
development3
evaluator
Grade implementation work against bead acceptance criteria using a separate judge agent. Use after subagent work passes mechanical gates, as a pre-merge check, or on-demand to evaluate existing features. The evaluator is NOT the orchestrator and NOT the implementer — it only judges. Integrates with browser-qa for runtime verification when CDT MCP is available.
tools3
debugging
Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes. Requires root cause investigation before any fix attempts. Random fixes waste time and create new bugs.
development3
agent-dx-cli
Patterns for designing command-line tools that agents can use effectively. Use when designing new CLIs, reviewing existing CLIs for agent compatibility, or adding agent-friendly features. Covers minimal ceremony, JSON output, context injection, batch operations, and error handling.
tools3
teammate
Activate when you are a teammate in an Agent Teams configuration. Establishes teammate protocol with file ownership, self-claiming tasks, inter-agent communication, quality gates, and escalation.
testing3
narrative-design
Quest structure, branching narrative architecture, environmental storytelling, dialogue design, and narrative pacing. Use when designing quest systems, writing branching dialogue, structuring story arcs, when narrative feels disconnected from gameplay, when players skip cutscenes, when story contradicts mechanics, or when quests feel like checklists instead of journeys. Treats narrative as a GAME SYSTEM that interacts with other systems — not a layer painted on top. Deepens experience-design's brief Narrative Integration section into full quest architecture, branching patterns, player agency, and narrative health evaluation.
testing3
encounter-design
Spatial design, enemy behavior, encounter composition, and environmental flow. Use when designing combat encounters, enemy AI, level layouts, boss fights, environmental puzzles, placing enemies or items in space, designing world structure, or when encounters feel repetitive, unfair, or tactically flat. Covers the Encounter Triangle (space, adversaries, resources), combat space vocabulary, enemy archetypes, AI behavior patterns, encounter pacing, environmental guidance, world structure, and environmental storytelling.
testing3
solid-architecture
Use when writing, reviewing, or refactoring code that involves structural decisions. Provides SOLID principles, composition patterns, module organization, and side-effect boundary guidelines.
development3