GameEngine

Guide proper usage of Editor UI infrastructure including Drawers (ButtonDrawer, ModalDrawer, TableDrawer, etc.), Elements (drag-drop targets, ComponentSelector), FieldEditors, and EditorUIConstants. Use when implementing editor panels, component editors, or any ImGui UI code to ensure consistency and code reuse.

Use before complex creative work — new features, multi-component systems, or behavior changes with real design trade-offs. Explores user intent, requirements and design before implementation. DO NOT use for non-complex tasks (bug fixes, small tweaks, single-file changes, obvious one-path work) — that is overkill.

Whole-repo audit for over-engineering. Like ponytail-review, but scans the entire codebase instead of a diff: a ranked list of what to delete, simplify, or replace with stdlib/native equivalents. Use when the user says "audit this codebase", "audit for over-engineering", "what can I delete from this repo", "find bloat", "ponytail-audit", or @ponytail-audit. One-shot report; does not apply fixes.

Harvest every `ponytail:` comment in the codebase into a debt ledger, so the deliberate shortcuts and deferrals ponytail leaves behind get tracked instead of rotting into "later means never". Use when the user says "ponytail debt", @ponytail-debt, "what did ponytail defer", "list the shortcuts", "ponytail ledger", or "what did we mark to do later". One-shot report; changes nothing.

Show ponytail's measured impact as a compact scoreboard: less code, less cost, more speed, from the benchmark medians. One-shot display, not a persistent mode, and not a per-repo number. Trigger: @ponytail-gain, "ponytail gain", "what does ponytail save", "show ponytail impact", "ponytail scoreboard".

Quick-reference card for all ponytail modes, skills, and commands in Cursor. One-shot display, not a persistent mode. Trigger: @ponytail-help, "ponytail help", "what ponytail commands", "how do I use ponytail".

Code review focused exclusively on over-engineering. Finds what to delete: reinvented standard library, unneeded dependencies, speculative abstractions, dead flexibility. One line per finding: location, what to cut, what replaces it. Use when the user says "review for over-engineering", "what can we delete", "is this over-engineered", "simplify review", or invokes @ponytail-review. Complements correctness-focused review; this one only hunts complexity.

Forces the laziest solution that actually works, simplest, shortest, most minimal. Channels a senior dev who has seen everything: question whether the task needs to exist at all (YAGNI), reach for the standard library before custom code, native platform features before dependencies, one line before fifty. Supports intensity levels: lite, full (default), ultra. Use on ANY coding task: writing, adding, refactoring, fixing, reviewing, or designing code, and choosing libraries or dependencies. Also use whenever the user says "ponytail", "be lazy", "lazy mode", "simplest solution", "minimal solution", "yagni", "do less", or "shortest path", or complains about over-engineering, bloat, boilerplate, or unnecessary dependencies. Also use when the user invokes @ponytail or includes a level (lite, full, ultra) with a coding task. Do NOT use for non-coding requests (general knowledge, prose, translation, summaries, recipes).

Guardrails and workflow for creating games on this engine using sample patterns (Snake, FlappyBird, TicTacToe), scripting tiers, project layout, and readiness limits. Use when scaffolding a new game, adding gameplay scripts/systems/components under games/ or assets/scripts/, publishing a game, or when the user asks how to build a game with the engine.

Updates README.md and docs/ for a single named engine module by reading only that module's source paths. Use when the user invokes /update-module-docs or /updating-module-docs, passes a module name to update documentation, or asks to refresh docs for one subsystem (rendering, scene, scripting, physics, audio, ecs, editor, etc.). Never scans the whole codebase.

Scans a given module (source directory) for missing unit tests. Discovers source types, checks for corresponding test files, and reports coverage gaps. Optionally generates test stubs following project conventions. Use when adding new code, ensuring test coverage, onboarding to the existing test suite, or invoking /scanning-test-coverage.

Performs deep architectural review of a single game engine subsystem — decoupling, ECS fit, editor/runtime separation, scalability, maintainability. Use when the user asks for architecture review, subsystem design review, module architecture audit, or invokes /reviewing-game-engine-architecture.

Step-by-step workflow for creating new editor panels including interface design, DI registration, EditorLayer integration, and menu bar setup. Focuses on panel architecture and lifecycle, not UI component APIs.

Analyze Entity Component System implementations for performance bottlenecks including entity iteration efficiency, system priority ordering, memory allocation patterns in hot paths (OnUpdate, rendering loops), cache coherency, LINQ allocations, and boxing issues. Use when reviewing ECS code for optimization, debugging slow entity updates, or investigating frame rate drops.

Create ECS component editors using IComponentEditor interface, ComponentEditorRegistry.DrawComponent wrapper, VectorPanel for vectors, and UIPropertyRenderer for simple properties. Covers registration in DI container and manual change detection patterns.

Guide the creation of new ECS systems following established architectural patterns including ISystem implementation, priority assignment, scene interaction, and dependency injection registration. Use when adding new system types to the engine or extending existing system functionality.

Compress natural language memory files (CLAUDE.md, todos, preferences) into caveman format to save input tokens. Preserves all technical substance, code, URLs, and structure. Compressed version overwrites the original file. Human-readable backup saved as FILE.original.md. Trigger: /caveman-compress <filepath> or "compress memory file"

Guide users through a structured workflow for co-authoring documentation. Use when user wants to write documentation, proposals, technical specs, decision docs, or similar structured content. This workflow helps users efficiently transfer context, refine content through iteration, and verify the doc works for readers. Trigger when user mentions writing docs, creating proposals, drafting specs, or similar documentation tasks.

Guide the creation of new ECS components following established architectural patterns including component class creation, JSON serialization support, editor UI implementation, dependency injection registration, and documentation. Use when adding new component types to the engine or extending existing component functionality.

Review code for proper DI patterns using DryIoc. Ensures no static singletons, validates constructor injection and service lifetimes. Use when reviewing code, refactoring static access, or debugging DI issues.

Implement IFieldEditor interface for custom type rendering in script inspector. Covers reflection-based field editing, FieldEditorRegistry registration, boxing/unboxing patterns, and extending the field editor system for new types.

Comprehensive guide for using Editor UI Drawers (ButtonDrawer, ModalDrawer, TableDrawer, TreeDrawer, LayoutDrawer, TextDrawer, DragDropDrawer). Use when implementing any UI in editor panels to ensure consistency.

Audit resource management including IDisposable pattern implementation, proper cleanup of OpenGL resources (buffers, textures, shaders, framebuffers), memory leak detection, resource lifetime management, and GPU resource tracking. Use when investigating memory leaks, GPU resource exhaustion, or implementing new resource types.

Validates platform abstraction compliance - ensures rendering code uses IRendererAPI interfaces, no direct OpenGL in engine core, proper namespace isolation. Reviews graphics features and guides alternative backend implementation.

Review JSON serialization for scenes, prefabs, and components. Use when: (1) implementing serializable components, (2) debugging save/load failures, (3) adding asset types, (4) reviewing serialization code, (5) investigating data corruption, (6) implementing JsonConverters.