HungryKelvin123

architect

Design typed Luau ownership, module boundaries, remotes, state, persistence, and lifecycle before broad or load-bearing Roblox changes. Use for $architect or when skipping design could lock in the wrong shape.

arena

Compare isolated, parent-defined alternatives against a concrete rubric and synthesize the result. Use for $arena or an explicitly requested candidate comparison.

automate-me

Use for "automate me", "create/update/refresh my -mode skill", "turn/capture my preferences or working style into a skill", or wanting agents to follow how the user works. Drafts or revises a personal -mode skill through skill-creator and unslop, optionally using supported recent task history.

david-mode

Roblox engineering workflow router with direct phases, evidence-first design, security, performance, review, and verification discipline. Invoke explicitly with $david-mode.

figure-it-out

Design an auditable playbook when no narrower one fits: a large migration, an ambitious multi-part change, or work a human reviews after stepping away. Scales rigor to the task, runs a hypothesis loop, and logs decisions via show-me-your-work. Use for /figure-it-out, 'figure it out', a large migration, or when no narrower playbook applies.

interrogate

Challenge risky Roblox code or designs with bounded, independent read-only worker reviews and parent judgment. Use for $interrogate, adversarial review, or finding blind spots.

principle-build-the-lever

Apply to any non-trivial work, not just bulk work: edits, migrations, analyses, checks. Build the tool that does it or proves it (codemod, script, generator, or a skill your subagents follow) instead of working by hand. The tool is the artifact a reviewer can rerun.

recall

Reconstruct your recent working context from your own chat history, live state, and the shared record (user reports, prior fixes, incidents), then hand back a tight current-state brief. Use for 'recall my work on X', 'catch me up', 'what have I been working on', 'where did I leave off', before starting or resuming work.

reflect

Review active-task history through judgment, tooling, and divergent lenses, then propose durable skill improvements. Use when the user says reflect.

setup-dstack

Configure DStack for Claude Code or Codex, verify the Roblox skill surface and guarded reviewer lanes, and optionally add a bounded startup instruction. Use only for explicit setup, installation checks, client changes, or reviewer configuration; do not use for ordinary Roblox implementation work.

Code & Development Listed

show-me-your-work

Keep a reviewable decision trail for long-running or unattended work: a TSV log with one row per decision (what, why, evidence, result). Local by default; commit it when a reviewer needs the trail to trust the result. Use for $show-me-your-work, autonomous or multi-phase runs, or work a human reviews after stepping away.

Data & Documents Listed

swarm

Coordinate independent routine execution or exploration batches and return one reviewed report. Use for $swarm or large separable work that justifies parallel overhead.

teach

Explain a body of work plainly so a person actually understands it. Runs the `how` and `why` skills and weaves what they find into one clear explanation. Use for 'teach me this', 'help me really understand X', 'explain this change or subsystem to me'.

Data & Documents Listed

roblox-data

Design or review Roblox persistence, schemas, session ownership, retries, and cross-server state.

roblox-monetization

Design or review Roblox developer products, passes, subscriptions, and retry-safe purchase fulfillment.

roblox-networking

Design or review Roblox remotes, replication protocols, payloads, reliability, and server validation.

roblox-physics

Design or review Roblox assemblies, constraints, collision, hit detection, and network ownership.

roblox-ui

Design or review responsive Roblox interfaces across touch, keyboard, mouse, and gamepad input.

Code & Development Listed

technical-writing

Layered technical-writing standard: Diátaxis structure, Google developer style sentences, STE instruction rules, Global English syntax. Use for $technical-writing or when writing or reviewing docs, RFCs, readmes, PR descriptions, or commit messages.

unslop

Cut AI tells from any writing. Must always apply.

principle-guard-the-context-window

Apply when context is filling up from large outputs, long files, or repeated reads. Filter bulk evidence and isolate bounded exploration when delegation earns its overhead.

Code & Development Listed

principle-make-operations-idempotent

Apply when designing commands, lifecycle steps, or processing loops that run amid crashes, restarts, and retries. Converge to the same end state regardless of partial prior runs.

principle-never-block-on-the-human

Apply when tempted to ask 'should I do X?' on reversible work. Proceed, present the result, let the human course-correct after the fact; reserve confirmation for irreversible actions.

API & Backend Listed

blast-radius

Find what a Roblox change can break across client/server contracts, remotes, saved data, replication, authored Instances, mobile performance, and dependent systems.

create-verification-skill

Create a project-local Roblox verification skill for Rojo assembly, existing Luau tests, source invariants, authored-context checks, and explicit user-run Studio scenarios.

API & Backend Listed

how

Trace how a Roblox subsystem works across Instances, Luau modules, remotes, server authority, replication, persistence, and client presentation.

Data & Documents Listed

luau-best-practices

Apply when reading or editing Roblox Luau for typed APIs, module boundaries, instance lifecycles, error handling, and maintainable data-oriented code.

maintain-verification-skill

Audit and update a project-local Roblox verification skill when code, Rojo mappings, tests, remotes, data schemas, or authored contracts change.

no-comments

Review Roblox Luau comments and suppressions, deleting narration while preserving non-obvious invariants, platform constraints, and authored contracts.

principle-boundary-discipline

Apply when wiring validation, error handling, or framework adapters. Concentrate guards at system boundaries (CLI, config, network, external APIs); trust internal types and keep business logic in pure functions.

principle-encode-lessons-in-structure

Apply when you catch yourself writing the same instruction a second time, or notice a recurring correction. Encode the rule as a lint, metadata flag, runtime check, or script instead of more text.

principle-exhaust-the-design-space

Apply when facing a novel UI interaction or architectural decision with no precedent in the codebase. Build 2-3 competing prototypes and compare side by side before committing.

principle-experience-first

Apply when product, UX, or feature-scope tradeoffs come up. Choose user delight over implementation convenience; ship fewer polished features over more rough ones.

principle-fix-root-causes

Apply when debugging. Trace each symptom to its root cause and fix it there; reproduce first, ask why until you reach it, resist nil-check guards that silence crashes.

principle-foundational-thinking

Apply before writing logic: choosing core types and data structures, sequencing scaffold-vs-feature work, asking what concurrent actors share. Get the data structures right so downstream code becomes obvious.

principle-laziness-protocol

Apply when refactoring, evaluating diff size, or tempted to add abstractions, layers, or signal threading. Bias toward deletion and the smallest change that solves the problem.

principle-migrate-callers-then-delete-legacy-apis

Apply when introducing a new internal API while old callers still exist. Migrate callers and delete the old API in the same wave instead of preserving compatibility layers.

principle-minimize-reader-load

Apply when reviewing or shaping code that's hard to trace. Count layers between question and answer, and hidden state in the reader's head; collapse one-caller wrappers and shrink mutable scope.

principle-model-the-domain

Apply when writing stateful logic, or when code branches a lot or repeats a shape assumption across files. Encode the domain in a structure instead of scattered conditionals.

principle-outcome-oriented-execution

Apply during planned rewrites and migrations with explicit phase boundaries. Converge on the target architecture; don't preserve smooth intermediate states with throwaway compatibility code.

principle-prove-it-works

Apply after completing a task, before declaring done. Verify against the real artifact (run the feature, read the actual value, inspect the diff), not a proxy, self-report, or 'it compiles.'

principle-redesign-from-first-principles

Apply when integrating a new requirement into an existing design. Redesign as if the requirement had been a foundational assumption from day one, instead of bolting it on.

principle-separate-before-serializing-shared-state

Apply when concurrent actors might write to the same file, branch, key, or state object. Eliminate the sharing first; serialize structurally only when one shared writer is a real invariant.

principle-sequence-verifiable-units

Apply to multi-step work (sweeps, migrations, runs of similar edits) and to how you stack commits and PRs. Break work into small units that each end in a verifiable state, check each before the next, and order delivery so the sequence proves itself to a reviewer.

principle-subtract-before-you-add

Apply when sequencing an addition, refactor, or rewrite. Remove dead weight, redundant validators, and stub references first, then build on the simpler base.

principle-type-system-discipline

Apply when designing typed Luau state or function contracts. Model variants explicitly, narrow boundary data, avoid dishonest casts, and derive shared shapes from one authority.