godot-compound

Create engaging changelogs for recent merges to main branch

Enhance a plan with parallel research agents for each section to add depth, best practices, and implementation details

Explore requirements and approaches through collaborative dialogue before planning implementation

Document a recently solved problem to compound your team's knowledge

Transform feature descriptions into well-structured project plans following conventions

Perform exhaustive code reviews using multi-agent analysis, ultra-thinking, and worktrees

Execute work plans efficiently while maintaining quality and finishing features

Create a new custom slash command following conventions and best practices

Fix incorrect SKILL.md files when a skill has wrong instructions or outdated API references

Full autonomous engineering workflow

Report a bug in the godot-compound plugin

Reproduce and investigate a Godot bug using codebase analysis, headless game launch, and GUT tests

Resolve all TODO comments using parallel processing

Resolve all pending CLI todos using parallel processing

Full autonomous engineering workflow using swarm mode for parallel execution

Triage and categorize findings for the CLI todo system

Researches and synthesizes external best practices, documentation, and examples for any technology or framework. Use when you need industry standards, community conventions, or implementation guidance.

Gathers comprehensive documentation and best practices for frameworks, libraries, or dependencies. Use when you need official docs, version-specific constraints, or implementation patterns.

Performs archaeological analysis of git history to trace code evolution, identify contributors, and understand why code patterns exist. Use when you need historical context for code changes.

Searches docs/solutions/ for relevant past solutions by frontmatter metadata. Use before implementing features or fixing problems to surface institutional knowledge and prevent repeated mistakes.

Conducts thorough research on repository structure, documentation, conventions, and implementation patterns. Use when onboarding to a new codebase or understanding project conventions.

Final review pass to ensure code is as simple and minimal as possible. Use after implementation is complete to identify YAGNI violations and simplification opportunities.

Reviews GDScript files for static typing, member ordering, naming conventions, signal architecture, and Resource safety patterns. Use when .gd files are created or modified.

Reviews scene composition, signal flow, autoload usage, and inheritance depth against Godot architecture principles. Use when scenes are created, refactored, or when inter-scene communication changes.

Verifies export preset configuration, asset integrity, scene reference completeness, and .uid consistency for build exports. Use when export presets change or before release builds.

Reviews GDScript and scene tree patterns for performance: _process abuse, untyped hotpaths, scene traversal costs, and memory patterns. Use when performance-sensitive code is written or modified.

Reviews signal emission timing, await race conditions, call_deferred requirements, queue_free safety, and autoload initialization order. Use when signal flow, async operations, or scene lifecycle code is modified.

Analyzes code for design patterns, anti-patterns, naming conventions, and duplication. Use when checking codebase consistency or verifying new code follows established patterns.

Reviews resource integrity: .tres/.tscn reference validation, .uid sidecar consistency, shared Resource mutation detection, and res:// path safety. Use when resource or scene files are created, moved, or modified.

Systematically reproduces and validates bug reports to confirm whether reported behavior is an actual bug. Use when you receive a bug report or issue that needs verification.

Runs gdformat and gdlint checks on GDScript files for formatting and style compliance. Use when checking code formatting or before commits.

Addresses PR review comments by implementing requested changes and reporting resolutions. Use when code review feedback needs to be resolved with code changes.

Analyzes specifications and feature descriptions for user flow completeness and gap identification. Use when a spec, plan, or feature description needs flow analysis, edge case discovery, or requirements validation.

This skill should be used before implementing features, building components, or making changes. It guides exploring user intent, approaches, and design decisions before planning. Triggers on "let's brainstorm", "help me think through", "what should we build", "explore approaches", ambiguous feature requests, or when the user's request has multiple valid interpretations that need clarification.

Capture solved problems as categorized documentation with YAML frontmatter for fast lookup

Expert guidance for creating Claude Code skills and slash commands. Use when working with SKILL.md files, authoring new skills, improving existing skills, creating slash commands, or understanding skill structure and best practices.

This skill should be used to refine brainstorm or plan documents before proceeding to the next workflow step. It applies when a brainstorm or plan document exists and the user wants to improve it.

This skill should be used when managing the file-based todo tracking system in the todos/ directory. It provides workflows for creating todos, managing status and dependencies, conducting triage, and integrating with slash commands and code review processes.

Run GDScript formatting and lint checks using gdtoolkit (gdformat + gdlint). Use before committing GDScript code.

This skill manages Git worktrees for isolated parallel development. It handles creating, listing, switching, and cleaning up worktrees with a simple interactive interface, following KISS principles.

Godot 4 architectural patterns for GDScript scene composition, resource management, and signal-based communication. Use when generating, reviewing, or refactoring GDScript code or Godot scenes.

This skill should be used when orchestrating multi-agent swarms using Claude Code's TeammateTool and Task system. It applies when coordinating multiple agents, running parallel code reviews, creating pipeline workflows with dependencies, building self-organizing task queues, or any task benefiting from divide-and-conquer patterns.

Resolve all PR comments using parallel processing. Use when addressing PR review feedback, resolving review threads, or batch-fixing PR comments.

Detect Godot project configuration (project.godot, GUT, gdtoolkit) and write compound-engineering.local.md with Godot review agents. Use when setting up a Godot project for /gc:review.