everything-game-dev-code

Commands are the preferred entry points for work in this scaffold. Each command defines a specific task, the conditions under which it applies, and which agents it invokes. Starting work through a command ensures the right roles are activated and the right standards are applied.

Review 2D art assets for naming, resolution, atlas config, animation, tilemap rules, and placeholder readiness.

Functional audio review for implementation, mix coverage, clarity, and player feedback.

Classify bugs, assign severity and priority, and propose next actions.

Review the current state against certification and platform compliance expectations.

Design or revise combat rules, variables, readability, and tuning direction.

Design or review the economy, sinks, faucets, rewards, and balance assumptions.

Turn repeated solutions and project lessons into reusable skills or patterns.

Build a complete game from idea to playable build, executing every phase end-to-end.

Create or update the Game Design Document for the current feature, system, or project.

Diagnose and resolve Godot export, script, or project configuration issues.

Review a Godot project for structure, architecture, maintainability, and risk.

Audit Godot scenes, nodes, autoloads, and scene composition patterns.

Set up or normalize a Godot project according to the scaffold rules.

Capture and summarize project learnings worth preserving.

Design or revise level flow, beats, pacing, and encounter structure.

Create a concise live operations brief for an event, offer, patch, or campaign.

Define or review memory budgets, ownership, and key memory risks.

Create or revise a milestone plan with goals, dependencies, risks, and exit criteria.

Review multiplayer architecture, authority, sync, and failure handling.

Design or revise onboarding, tutorials, and first-session learning flow.

Coordinate multiple agents to solve a complex cross-discipline task.

Generate patch notes for internal, QA, or player-facing use.

Define or review performance budgets, profiling priorities, and target constraints.

Plan implementation before changing code or content.

Synthesize playtest findings into decisions, risks, and follow-up actions.

Build a QA plan, matrix, and exit criteria for the selected scope.

Design or revise quest structure, objectives, gating, and state flow.

Plan or execute a focused cleanup that reduces technical debt safely.

Run a release readiness review with blockers, waivers, and go/no-go signals.

Review save/load architecture, persistence risks, and migration concerns.

Generate a Unity Editor script that populates a scene with GameObjects, attaches scripts, wires inspector references, and saves — making the game immediately playable.

Create a new reusable game development skill from a proven pattern.

Apply test-driven development or regression-driven implementation for the current task.

Create or update a technical design document for the selected feature or system.

Define events, schemas, questions, KPIs, and validation for telemetry.

Review internal tooling, editor workflows, and automation quality.

Review UI visual assets for naming, 9-slice config, atlas packing, theme consistency, and animation conventions.

Review menus, HUD, navigation, and player flow from a UX perspective.

Diagnose and resolve Unity build, editor, package, or configuration issues.

Generate placeholder sprites, prefabs, and audio stubs for a Unity project so the game is visually testable before final assets exist.

Review a Unity project for structure, architecture, maintainability, and risk.

Audit Unity scenes, prefabs, serialized references, and scene flow patterns.

Set up or normalize a Unity project according to the scaffold rules.

Audit Unreal Blueprints, graph structure, ownership, and maintainability.

Diagnose and resolve Unreal build, packaging, plugin, or configuration issues.

Review an Unreal project for structure, architecture, maintainability, and risk.

Set up or normalize an Unreal project according to the scaffold rules.

Update living documentation so design, implementation, and validation stay aligned.

Run a structured verification pass across implementation, quality, and risk.

Define or review a vertical slice with clear goals, proof points, and acceptance criteria.

Owns 2D art pipeline quality — sprites, tilemaps, 2D animations, UI visual assets, and placeholder assets.

Agent files define the specialized roles that carry out work in this scaffold. Each agent has a fixed identity, a set of responsibilities, and a declared toolset. When a command invokes an agent, it activates that agent's behavior and constraints for the duration of the task.

Reviews accessibility, rebindings, contrast, readability, and inclusive UX coverage.

Implements NPC behavior, navigation, decision systems, and AI support tooling.

Implements animation state logic, blending, sync, and event-driven hooks.

Designs system boundaries, technical architecture, and integration strategy.

Designs reactive audio, music, SFX, and functional mix behavior.

Owns build automation, CI reliability, packaging, and artifact discipline.

Reviews code quality, architecture fit, maintainability, and technical risk.

Designs combat rules, abilities, weapons, states, and initial balance targets.

Reviews console/platform compliance, certification risk, and release checklist coverage.

Keeps GDD, TDD, runbooks, and operational docs aligned with reality.

Designs currencies, sinks, rewards, tuning logic, and economy health.

Implements gameplay loops, interaction systems, and mechanics.

Creates and maintains the Game Design Document and player-facing intent.

Resolves Godot export, project configuration, and script/runtime build blockers.

Reviews Godot architecture, scene structure, resource usage, and engine-specific risks.

Designs level flow, pacing, encounter beats, navigation, and space usage.

Owns live events, offers, telemetry-informed updates, and post-launch operational planning.

Reviews mobile F2P retention, monetization, economy pressure, and live-ops implications.

Designs narrative arcs, dialogue, quest framing, and worldbuilding.

Implements authority, replication, synchronization, and networked gameplay safety.

Reviews CPU, GPU, memory, loading, and budget risk across systems and content.

Implements movement, collisions, simulation behavior, and game feel through physics.

Plans features, milestones, vertical slices, and execution order.

Synthesizes playtest observations, findings, and priority recommendations.

Owns roadmap pressure, milestone health, delivery risks, and coordination.

Owns QA strategy, coverage planning, regression scope, and release confidence signals.

Reduces technical debt, simplifies architecture, and improves maintainability.

Owns go/no-go framing, release checklists, and coordination of final release readiness.

Reviews secrets handling, external services, data trust boundaries, and abuse risks.

Designs systems, progression, economy relationships, and player goals.

Owns art pipeline quality, shaders, import settings, and runtime visual performance.

Owns technical design documents, interfaces, constraints, and implementation strategy.

Designs instrumentation goals, event quality expectations, and behavior analysis loops.

Builds internal tools, editor workflows, validators, and production automation.

Implements HUD, menus, settings, and UI interaction flows.

Designs HUD, menus, onboarding, interaction flow, and player-facing clarity.

Resolves Unity editor, package, and platform build failures.

Reviews Unity architecture, project structure, engine integration, and Unity-specific risks.

Resolves Unreal compilation, packaging, module, and plugin failures.

Reviews Unreal architecture, content boundaries, engine integration, and Unreal-specific risks.

Define authoring, import, and state machine rules for frame-by-frame and skeletal 2D animations.

Define a visual direction that artists, UI, technical art, and marketing can execute consistently.

Integrate music, SFX, VO, mixing, and reactive audio behavior so audio supports gameplay and UX.

Plan and implement cinematic content without breaking gameplay flow, performance, or content maintainability.

Manage dialogue and text content so it remains editable, implementable, localizable, and testable.

Define acceptance, validation, and runtime integration rules for raster assets generated with image models before they become real project content.

Prepare the project for translation, cultural adaptation, text expansion, and voice or subtitle variability.

Define creation, naming, and replacement rules for placeholder assets so the game is testable before final art exists.

Define import, slicing, atlas packing, and naming rules for 2D sprite assets.

Align content creation, shaders, import settings, runtime presentation, and performance constraints.

Define tileset creation, auto-tile rules, collision shapes, and tilemap configuration for 2D levels.

Define transition, feedback, and state-driven animation rules for UI elements.

Define import, 9-slice, atlas packing, theming, and naming rules for UI visual assets (buttons, panels, icons, bars).

Create VFX authoring and integration rules that preserve readability, style fit, and performance.

Build accessibility into design decisions instead of treating it as late-stage options work.

Design combat verbs, enemy pressure, resource economy, readability, and tuning hooks.

Define the primary player activity loop and the support loops that sustain mastery, variety, and progression.

Design and tune currencies, sinks, rewards, prices, and inflation control so the economy supports progression and retention.

Shape level flow, pacing, navigation, encounter staging, and spatial teaching.

Design seasonal, event, or post-launch content that extends engagement without destabilizing the core product.

Design monetization systems that fit the product, respect player trust, and remain technically and legally manageable.

Build narrative structure, world logic, dialogue intent, and player motivation that support the game loop.

Teach the player the game clearly, gradually, and in a way that supports retention rather than overload.

Structure long-term and short-term progression so players experience growth, goals, and retention without uncontrolled complexity.

Design objective structure, gating, branching, and player guidance for mission-like content.

Design maintainable AI behavior structures for decision-making, navigation, combat, and systemic interaction.

Structure animation state, blending, events, and sync so authored motion remains reliable under gameplay pressure.

Keep content discoverable, versioned, licensed, budgeted, and safe to move through the pipeline.

Structure build and CI pipelines so builds are reproducible, diagnosable, and release-friendly.

Use events and messaging without creating hidden coupling, ordering bugs, or impossible debugging paths.

Define system ownership, boundaries, state flow, and extensibility for gameplay code across engines.

Design input around player intent and supported device families instead of hardcoding device-specific behavior everywhere.

Define residency and memory budgets so content, streaming, and runtime systems fit target platforms.

Define ownership, authority, replication, prediction, rollback or reconciliation strategy for multiplayer systems.

Set and manage frame, load, memory, streaming, or bandwidth budgets before performance debt becomes structural.

Use physics and collision in a way that supports feel, determinism expectations, and performance constraints.

Define reliable persistence boundaries, save formats, recovery behavior, and migration policy.

Implement analytics and observability hooks that answer product questions without creating noise or privacy risk.

Design internal tools and content pipelines that reduce manual work and make authoring safer.

Structure HUD and menu implementation so UI remains understandable, maintainable, and aligned with UX goals.

Run Godot export, CI, and release packaging with reproducible presets and platform-aware checks.

Use C# in Godot with clear interop boundaries, node ownership, and engine lifecycle awareness.

Create Godot editor tools, inspectors, import helpers, and validation flows that reduce manual authoring risk.

Apply GDScript standards that keep scene-driven projects readable, maintainable, and safe to refactor.

Profile Godot runtime, scene, rendering, and resource behavior based on representative builds and content.

Organize Godot project files so scenes, scripts, resources, addons, tests, and export assets stay predictable.

Manage Godot resources, scenes, and imported assets so references, loading, and sharing behavior remain safe and efficient.

Structure scenes, nodes, autoloads, and resources so Godot projects remain scalable and understandable.

Use signals for decoupling without creating hidden event webs, ownership confusion, or lifecycle bugs.

Choose effective automated and manual test layers for Godot features without overcomplicating the project.

Classify bugs by player impact, reproducibility, severity, and milestone risk so the team fixes the right things first.

Create operational checklists for legal, accessibility, privacy, platform, and product compliance obligations.

Prepare the project for console platform requirements, TRCs/TCRs/XRs, and first-party submission expectations.

Handle crashes as high-severity defects with reproducibility, symbol quality, clustering, and release impact in mind.

Build a coverage matrix that shows what must be tested, on which configurations, and at what milestone confidence level.

Evaluate whether a build is genuinely ready for external testing, certification, store submission, or launch.

Prepare store-facing assets, metadata, compliance paperwork, and packaging details for submission.

Use Addressables with explicit grouping, loading, update, and fallback rules instead of ad hoc content loading.

Run Unity builds, CI, and release packaging with reproducible configuration and platform-aware checks.

Apply Unity-specific C# standards that preserve readability, testability, and safe engine integration.

Create Unity editor tools that make content production safer, faster, and less dependent on tribal knowledge.

Use common Unity gameplay architecture patterns without hiding ownership inside scenes or inspector wiring.

Implement Unity input with explicit action maps, device support, and UI/gameplay separation.

Profile and optimize Unity projects based on player-build evidence, not editor intuition.

Organize Unity project paths so code, content, tests, editor tooling, and build assets stay discoverable and maintainable.

Choose the right mix of plain C#, edit mode, play mode, and smoke testing for Unity features.

Choose and operate Unity render pipelines with clear platform, tooling, shader, and content implications.

Use Blueprints for iteration and authored behavior without letting graph sprawl become hidden architecture.

Run Unreal builds, packaging, CI, and release packaging with reproducible configuration and platform-aware checks.

Apply C++ standards that fit Unreal lifecycle, reflection, modules, and gameplay framework concerns.

Create Unreal editor tools, validators, utility widgets, or commandlets that reduce manual work and pipeline risk.

Use the Unreal gameplay framework intentionally so authority, ownership, and system lifetime are understandable.

Use Gameplay Ability System or equivalent ability frameworks with clear ownership, data flow, and tuning hooks.

Profile packaged Unreal builds on target hardware and connect fixes to the real bottleneck domain.

Organize Unreal code, plugins, content, and config so ownership and build behavior stay clear.

Implement and review Unreal replication with explicit ownership, relevancy, authority, and failure behavior.

Choose effective Unreal automation and integration test layers without over-relying on brittle map-level tests.

Capture lessons learned from implementation, production, QA, and release so the project improves over time.

Create or update a Game Design Document that is actionable for design, engineering, QA, production, and content teams.

Build milestone plans that are dependency-aware, risk-aware, and tied to real delivery outcomes.

Coordinate multiple agents and disciplines so complex tasks are broken down cleanly and handed off without ambiguity.

Turn raw playtest observation into actionable design, UX, tuning, and production decisions.

Identify, track, and revisit the risks most likely to derail scope, quality, budget, or release readiness.

Apply test-driven development or test-first thinking to gameplay, tooling, and high-risk technical work.

Turn feature intent into a Technical Design Document that is implementable, reviewable, and testable.

Run a structured verification pass that checks behavior, edge cases, quality bars, and documentation alignment.

Define a vertical slice that proves gameplay, quality bars, and production viability without over-building the full game.