Ship the game, not AI slop.

Use when Unity implementation spans gameplay code plus serialized assets, architecture, general editor tooling, packages, or build configuration; use Game Tuning Workbench for a focused project-specific tuning panel and versioned settings handoff, and the dedicated Unity skills for debugging, project or dependency audits, reorganization, profiling, or WebGL procedures

Use when implementing or debugging browser-game features and rendering with Three.js, Phaser, PixiJS, vanilla JavaScript, Canvas, WebGL, or Unity WebGL source; use Realtime Multiplayer Engineer when work spans authoritative server simulation and network lifecycles, Game Art Director for cross-surface visual direction, and focused skills for bounded audits, input, performance, tuning, or portal integration

Use when real-time multiplayer implementation spans authoritative simulation, network protocol, admission and presence lifecycles, interest management, reconnection, persistence, spectators, or live-world recovery; use the dedicated persistent-server design, multiplayer security, or load-and-soak skill when only that bounded procedure is needed

Use when coordinating a web-game release across multiple portals, SDK workstreams, build variants, submission planning, and dashboard handoff; use Web Game Multi-Portal Adapter for the focused shared facade and deterministic-variant procedure, a dedicated platform skill for one portal, and Game Monetization Manager for IAP or ad policy

Use when a game on any engine or runtime needs remote configuration, feature flags, kill switches, analytics events, experiment instrumentation, staged rollout, or provider-neutral config and analytics adapters with an A/B experimentation workflow such as Firebase Remote Config, Analytics, and A/B Testing

Use when a game on any engine or runtime needs sustainable monetization strategy, an in-app purchase catalog or implementation, ad-format and placement decisions, store or mediation adapters, purchase lifecycle hardening, pricing plans, or monetization experiments with policy and player-experience guardrails

Use when designing or implementing game HUD information architecture, menus, onboarding, store, offer, ad, purchase, consent, navigation, focus, responsive interface, accessibility, or cross-device menu flows; use Game Juice & Feel for action feedback and Game Art Director for the broader visual language

Use when a game-design problem spans multiple interacting mechanics and needs a coherent implementable design; use focused skills for bounded loop, difficulty, economy, playtest, or interface work, Game Monetization Manager for commercial design, and Realtime Multiplayer Engineer for authoritative networking implementation

Use when coordinating and implementing a performance campaign across multiple targets or runtime subsystems; use a focused engine performance skill for bounded profiling, Realtime Multiplayer Engineer for network architecture and correctness, and the multiplayer load-and-soak skill for capacity or endurance validation

Use when game quality work spans ambiguous or multiple reports, exploratory coverage, severity and priority, test matrices, playtest classification, and release risk; use Unity Debugging for one focused Unity failure and Realtime Multiplayer Engineer for authoritative network repair

Use when a game feels flat, weightless, unclear, unresponsive, or unsatisfying and needs coordinated input, motion, animation, camera, hit-stop, VFX, audio, haptics, or action-HUD feedback; use Game Art Director for broad visual language, Game UI/UX for interface structure, and Realtime Multiplayer Engineer for synchronization correctness

Use when a game needs one coherent visual direction across gameplay, environments, characters, effects, interface styling, and honest marketing imagery, or when existing art lacks identity, hierarchy, readability, or a feasible production system

Use when a game needs a new look painted as one self-contained theme block, such as a seasonal or publisher variant or a portal A/B look, inside a separate copy of the game, with its own tests and mid-build captures; use Seasonal Theme Variant for the procedure, Game Art Director for the lasting visual language, Game UI/UX Designer for interface structure, and Portal Adapter Builder for the portal build

Use when one portal's build needs its adapter, build script, contract-mirroring mock verifier, local QA server and notes written in a scratch copy of the frozen game source from the portal's live contract; use Web Game Multi-Portal Adapter for the shared facade, the platform skill for the portal's API, Web Game Publishing Engineer for the wider release, and Portal Build Orchestration for the round

Audit an existing Unity project and map its architecture, scenes, prefabs, packages, settings, Addressables, Resources, runtime references, risks, and prioritized improvements. Use when inheriting a project, planning a refactor or Unity upgrade, preparing a release, diagnosing broad technical debt, or needing to understand how a Unity project is assembled before changing it.

Plan and execute safe Unity asset, script, prefab, scene, and folder moves while preserving GUIDs, meta files, serialized references, and build configuration. Use when reorganizing an Assets tree, renaming or relocating Unity content, splitting modules, cleaning inherited project structure, or repairing a previous move without breaking dependencies.

Trace forward and reverse Unity dependency graphs across scenes, prefabs, prefab variants, ScriptableObjects, Addressables, Resources.Load paths, GUIDs, and assets. Use when locating the serialized owner of a missing reference, finding what references an asset, investigating build inclusion, validating additive scene flows, or determining move, delete, and shared-content blast radius; use Unity Debugging instead to reproduce and repair one focused failure.

Reproduce, isolate, repair, and verify one focused Unity functional failure using Console, Editor and Player logs, stack traces, debugger evidence, serialized state, controlled experiments, and regression tests. Use for compiler or assembly errors, exceptions, functional crashes or hangs, missing references, broken scene or prefab behavior, lifecycle and state bugs, package or import failures, build-only and platform-only defects, IL2CPP or stripping problems, and intermittent behavior; use Unity Performance Profiling instead when the primary symptom is frame time, memory, loading or rendering cost, thermal behavior, or resource exhaustion.

Diagnose Unity CPU, GPU, memory, garbage-collection, rendering, physics, loading, and frame-pacing problems with reproducible profiler evidence. Use for low frame rate, stutter, hitches, thermal or battery issues, memory pressure, loading spikes, excessive draw calls, or performance regressions on a specific Unity target device.

Measure and optimize Unity WebGL build size, startup time, memory, runtime performance, browser compatibility, and hosting behavior. Use when a Unity game loads slowly, crashes or stutters in browsers, exceeds portal size limits, needs reliable compression and caching, or must be prepared for desktop and mobile web deployment.

Select between Three.js, Phaser, PixiJS, vanilla Canvas 2D, and vanilla WebGL using explicit game, platform, team, performance, and delivery constraints. Use when starting a browser game, choosing a stack for a prototype, reassessing an existing web game architecture, or deciding whether framework migration is worth its cost.

Profile and improve browser-game loading, frame time, input latency, memory, garbage collection, rendering, network delivery, and lifecycle behavior with before-and-after evidence. Use for slow startup, low FPS, stutter, long tasks, mobile overheating, memory growth, WebGL context loss, large bundles, or regressions in Three.js, Phaser, PixiJS, Canvas, or vanilla WebGL games.

Design and verify one responsive browser-game input layer across keyboard, mouse, touch, pen, and gamepad, including coordinate scaling, focus, resize, orientation, and lifecycle handling. Use when adding cross-device controls, fixing duplicate or dropped input, mapping pointer coordinates to a scaled canvas, reducing input latency, or making a web game reliable on desktop and mobile browsers.

Design, implement, or audit an authoritative real-time multiplayer server for a persistent game world, including simulation ticks, protocols, interest management, client reconciliation, admission queues, reconnects, spectators, checkpoints, safe restarts, security, and operational budgets. Use when players share a long-lived world or room and server correctness must survive churn and deployment; use Multiplayer Load and Soak Testing for capacity proof, and leave gameplay scoring, economy, and fairness values to the systems-design owner.

Plan, implement, or run authorized headless load and soak tests for an authoritative multiplayer game, covering player ramps, spikes, churn, spectators, dense interest areas, slow clients, bounded faults, restart recovery, and sustained operation. Use when concurrency, tick health, bandwidth, backpressure, state correctness, or safe capacity needs runtime evidence; do not target production or third-party systems without explicit scoped authorization.

Threat-model, audit, or harden a real-time multiplayer game against modified clients, automation, impossible or replayed input, state and visibility abuse, admission bypass, resource exhaustion, spectator leaks, and privileged-tool compromise. Use for a focused multiplayer security or abuse-resistance review with evidence, mitigations, and safe adversarial validation; use the runtime owner for broad server implementation and the load skill for capacity testing.

Design or implement the provider-neutral boundary that turns a verified external purchase into revocable game access. Use for hosted-checkout callbacks, signed commerce webhooks, durable entitlement state, purchaser-to-player binding, short-lived single-use join authorization, refund or chargeback revocation, reconciliation, and sandbox verification. Do not use for in-game store catalogs, advertising, pricing strategy, or gameplay admission, queue, matchmaking, and seat-allocation rules.

Design, implement, migrate, or audit a reusable multi-portal adapter for browser games across Unity Web, JavaScript or TypeScript frameworks, and other engines with documented browser interop. Use when one game targets two or more portals, or when an existing shared portal subsystem has scattered vendor calls, and needs a stable game-facing lifecycle, capability matrix, isolated provider modules, ads, save, score, pause and audio contracts, deterministic build variants, local fakes, and SDK-isolation tests; use only the dedicated platform skill when the work targets one provider, and Web Portal Readiness Check for final artifact QA.

Design, implement, test, or operate a provider-neutral livestream pipeline for a game-owned public or spectator view, including automatic camera direction, capture readiness, encoding, local relay, isolated destination publishers, rollover, observability, and secret handling. Use when gameplay should be broadcast to one or more video platforms; do not use for portal SDK packaging, player-controlled streaming, or ordinary gameplay rendering alone.

Integrate, repair, migrate, or audit the current official Poki SDK in HTML5 and Unity WebGL games. Use when preparing a game for Poki, wiring initialization and loading, gameplay, commercial-break, rewarded-break, or audio lifecycle behavior, validating in Poki Inspector, or diagnosing a rejected or broken Poki build.

Integrate, repair, migrate, or audit the current official CrazyGames SDK in HTML5 and Unity WebGL games. Use when preparing a Basic or Full Launch, wiring SDK initialization, gameplay and loading events, ads, saves, accounts, or portal preview behavior, or diagnosing CrazyGames QA and integration failures.

Verify, integrate, repair, or audit the official current GameDistribution SDK for HTML5 or Unity WebGL games. Use when preparing a GameDistribution build, adding ads or platform lifecycle handling, migrating an older GD integration, or diagnosing portal QA failures; require current first-party SDK evidence before changing code.

Adapt, package, test, or audit an HTML5 or Unity WebGL game for YouTube Playables. Use when integrating the current Playables SDK, readiness signals, pause and audio events, storage, score or ads APIs, making a self-contained compliant bundle, running the official test suite, or preparing an invitation-only Developer Portal certification release.

Integrate, repair, migrate, or audit the current official Wavedash SDK in browser games across any engine that exports to the web. Use when preparing a game for Wavedash, wiring initialization and load reporting, or adding player identity, achievements, leaderboards, cloud saves, UGC, multiplayer lobbies and P2P networking, or paid content. Always negotiate integration scope with the user before editing; never infer wanted features from the codebase.

Prepare, integrate, and audit an HTML5 or Unity WebGL game for Coolmath Games, covering the public eligibility gate, licensing removals, the dedicated build variant, and integration of the partner-supplied SDK once it is provided. Use when targeting Coolmath Games from Unity, Three.js, Phaser, PixiJS, Canvas, or vanilla JavaScript. Coolmath's SDK is not publicly documented, so never invent its API — obtain the developer's own bundle and documentation before wiring any call.

Audit an HTML5, WebGL, Canvas, Phaser, PixiJS, Three.js, vanilla JavaScript, or Unity WebGL build before submission to a web-game portal. Use for packaging, loading, iframe, browser, input, audio, storage, network, performance, SDK lifecycle, privacy, metadata, or multi-portal readiness checks and release go/no-go decisions.

Add a seasonal, holiday, or publisher-specific look to a shipped game as a separate copy of the game folder, with the default left untouched, one removable theme block plugged in through optional hooks, and one locked look per portal upload. Use when a game needs a themed variant for a season or a promotion, when a look must be decided from mockups, or when themed art must keep meters, icons and failure screens readable; not for the game's lasting art bible (use Game Art Director) or for a runtime theme switcher.

Render portal and store art (icons, logos, covers, thumbnails, contact sheets) from the game's own art by injecting a painter into a locked copy of the game page, then crop, convert and verify exact pixel sizes per portal. Use when a portal asks for specific image sizes, a title wordmark, clean no-branding variants, or art that must match the current look and be re-rendered when the game changes; not for choosing the art direction (use Game Art Director) or for gameplay video.

Coordinate a portal build round with several agents, namely a source owner that holds the game code and tests, a portal-adapter builder working in a scratch copy of the frozen source, and a lead who runs the final build after a source-hash handshake, with build and verification estimated separately, stage checkpoints, progressive delivery and a fixed hand-back report. Use when several looks or portals ship in one round or workstreams overlap on one game; not for one provider's contract (use its platform skill) or the shared adapter design (use Web Game Multi-Portal Adapter).

Use when reviewing an existing game's HUD, menus, navigation, readability, input flow, accessibility, localization readiness, or responsive behavior and turning the findings into prioritized implementation changes.

Use when players are confused, abandoning early, skipping tutorials, or failing to reach the first satisfying moment and the game's onboarding or first-session experience needs evidence-based improvement.

Use when a game feels repetitive, aimless, unrewarding, unclear, or unable to retain interest and its moment-to-moment actions, feedback, rewards, progression, and repeated player decisions need analysis.

Use when players encounter difficulty spikes, boredom, repeated failure, inconsistent challenge, unfairness, or poor progression and the game needs evidence-based diagnosis and tuning across levels or encounters.

Use when designing or correcting currencies, rewards, costs, upgrades, progression pacing, resource inflation, grind, monetization pressure, or exploitable source-and-sink relationships in a game economy.

Use when turning playtest notes, recordings, telemetry, surveys, bug reports, or conflicting player opinions into evidence clusters, root-cause hypotheses, and a prioritized change and validation plan.

Build a concept-specific, creator-facing game tuning workbench that exposes only meaningful camera, lighting, control, movement, difficulty, UI, VFX, audio, or other project parameters; previews candidates; and exports a versioned, validated draft settings package for specialist review and engine-specific application. Use only when the requested deliverable is an interactive tuning panel, visual variant workbench, or agent-readable settings handoff, not for ordinary tuning advice. Prefer an existing engine inspector or the smallest project-local tool. Do not use to choose or approve design values, create player-facing settings, deliver live configuration, prove performance or release quality, or build a new game engine by default.

Extract evidence-backed, product-neutral lessons from game-development milestones, design discussions, prototypes, implementations, playtests, incidents, releases, and postmortems; separate project handoff facts from reusable guidance; route validated lessons into the smallest appropriate agent, skill, resource, or registry change; and verify authorized AgentGuild updates. Use after meaningful game-production iterations, when maintaining a durable handoff or learning log, or when asked to improve shared game-development agents or skills from project experience. Do not use for ordinary status summaries or playtest-feedback triage alone.

Run a Gauntlet Loop for game production by decomposing an ambitious playable goal into judgeable workstreams, pairing builders with fresh-context critics, comparing real artifacts against explicit references or metrics, integrating coupled systems, and iterating within a defined budget. Use for vertical slices, major visual or gameplay polish passes, Claude-of-Duty-style production loops, or multi-system quality pushes where one-pass implementation is not enough; use a focused skill instead for one bug, audit, balance question, or regression check.

Plan and execute a risk-based regression pass on a candidate game release across gameplay, saves, UI, input, audio, performance, platform SDKs, packaging, and upgrades. Use before shipping a build, after engine or SDK changes, when validating a hotfix, or when deciding whether a release candidate is safe to promote.

Make a browser or mobile game look hand-crafted and feel alive instead of AI-generated. Before building, lock an identity (shape language, material, palette story, signature moment) and decide the look from a mockup sheet; after building, run a scored audit with measured checks (contrast, colour-blind and greyscale distinctness, 10 px icons, squint test, motion, sound, haptics) and fix in a separate copy. Use whenever the user says non-slop, slop, generic, samey, muddy, flat, lifeless, "make it feel better", polish, juice or art direction for a game, HUD, theme or icon set, even if they do not name the skill; not for rendering store art (store-art-from-game-art), seasonal copies (seasonal-theme-variant), or rules, economy and balance.