Blood-and-Gold

Read a prototype GDD and generate a phased implementation roadmap with concrete tasks, organized by implementation phases with specific deliverables and test criteria.

Generate complete, game-ready VFX scenes for Godot 4.x using NO custom art assets. Creates procedural effects using GPUParticles2D, ColorRect, Line2D, and geometric shapes. Use this when the user wants to create visual effects without sprites.

Implement tool features from roadmaps, building editor plugins, standalone tools, and CLI utilities for game development. Use this when implementing features from a tool roadmap.

Create phased implementation roadmaps for development tools, breaking them into MVP, enhancements, and polish phases with feature-level deliverables compatible with tool-feature-implementer.

Build and maintain a living architecture document tracking scene trees, data structures, system hierarchies, and game architecture. Use this when visualizing game structure, documenting scene hierarchies, or tracking data schemas.

Add animations to existing PixelLab characters. Lists available characters, shows animation templates organized by category (movement, combat, utility), and supports custom action descriptions. Use this when the user wants to animate a character sprite.

Generate concise specifications for development tools, editors, and utilities. Use this when planning a new tool, editor plugin, or standalone utility to assist with game development.

Debug errors from screenshots with deep analysis to fix the immediate issue and proactively identify related errors. Use this when the user provides an error screenshot, says "debug this", or wants to fix runtime/compile errors.

Create pixel art characters using PixelLab MCP with guided prompts for style consistency. Asks for description, size, art style, and validates against the project's existing art direction. Use this when the user wants to create a new character sprite for the game.

Create and update CHANGELOG.md files to track development progress, features, fixes, and changes. Use this when completing features, fixing bugs, or documenting project milestones.

Validate game concepts by analyzing technical feasibility, scope warnings, and comparing to similar games. Use this when the user has a game idea that needs stress-testing.

Analyze code to identify opportunities for data-driven design by extracting hardcoded values into JSON, .tres resources, or dedicated data files. Use this when the user wants to improve data management, make balancing easier, or separate code from configuration.

Execute data-driven refactorings from data-driven-refactor reports. Use this when the user wants to implement data extraction recommendations by creating data files and refactoring scripts.

Create and maintain a Game Design Bible documenting design vision, pillars, mechanics philosophy, and creative direction. Use this when establishing design principles or documenting high-level creative decisions.

Refine vague feature ideas into structured Feature Idea Briefs through interactive Q&A. Use this when the user has a rough idea that needs fleshing out before creating a full feature spec.

Implement a feature spec by creating all necessary scenes, scripts, and resources. Use this when the user wants to implement a documented feature from the docs/features/ directory.

Generate detailed feature specifications based on the project's feature spec template, using the prototype GDD and roadmap for context. Use this when the user wants to create a feature spec, document a new feature idea, or plan implementation for a game feature.

Generate game concepts through interactive constraint gathering. Use this when the user wants game ideas, needs inspiration, or wants to explore different game concepts based on their constraints.

Analyze GDScript code for quality, best practices, anti-patterns, and refactoring opportunities. Use this when the user wants to review code quality, check for Godot-specific issues, or improve code maintainability.

Execute code quality refactorings from gdscript-quality-checker reports. Use this when the user wants to implement the recommendations from a code review report.

Generate comprehensive Game Design Documents for full production games. Use this when transitioning from prototype to full game, or when planning a complete game from scratch.

Generate structured Game Design Documents for prototypes through interactive Q&A. Use this when the user wants to document a game concept, create a prototype GDD, or formalize their design ideas.

Analyze Godot scene files (.tscn) for structural issues, performance problems, and optimization opportunities. Use this when the user wants to optimize a scene, check scene structure, or troubleshoot scene-related issues.

Create and maintain a Systems Bible documenting all technical systems, their architectures, interactions, and implementation details. Use this when building systems, refactoring, or onboarding developers to the codebase.

Guide users through git workflows, best practices, commit messages, branching strategies, and resolving common version control issues. Use this when users need help with git operations or workflow decisions.

Expand a prototype GDD into a vertical slice GDD, adding polish, content scope, and quality bar definitions. Use this when prototype validates core mechanics and you're ready to build a polished representative slice.

Read a vertical slice GDD and generate a phased roadmap of features that need to be implemented, organized into logical phases with high-level feature descriptions.