Configure the project's game engine and version. Pins the engine in CLAUDE.md, detects knowledge gaps, and populates engine reference docs via WebSearch when the version is beyond the LLM's training data.
When this skill is invoked:
Three modes:
/setup-engine godot 4.6 — engine and version provided/setup-engine unity — engine provided, version will be looked up/setup-engine — fully guided mode (engine recommendation + version)If no engine is specified, run an interactive engine selection process:
design/gdd/game-concept.md if it exists — extract genre, scope, platform
targets, art style, team size, and any engine recommendation from /brainstorm"No game concept found. Consider running /brainstorm first to discover what
you want to build — it will also recommend an engine. Or tell me about your
game and I can help you pick."
Use this decision matrix:
| Factor | Godot 4 | Unity | Unreal Engine 5 |
|---|---|---|---|
| Best for | 2D games, small 3D, solo/small teams | Mobile, mid-scope 3D, cross-platform | AAA 3D, photorealism, large teams |
| Language | GDScript (+ C#, C++ via extensions) | C# | C++ / Blueprint |
| Cost | Free, MIT license | Free under revenue threshold | Free under revenue threshold, 5% royalty |
| Learning curve | Gentle | Moderate | Steep |
| 2D support | Excellent (native) | Good (but 3D-first engine) | Possible but not ideal |
| 3D quality ceiling | Good (improving rapidly) | Very good | Best-in-class |
| Web export | Yes (native) | Yes (limited) | No |
| Console export | Via third-party | Yes (with license) | Yes |
| Open source | Yes | No | Source available |
Present the top 1-2 recommendations with reasoning tied to the user's answers. Let the user choose — never force a recommendation.
Once the engine is chosen:
"[engine] latest stable version [current year]"Read CLAUDE.md and update the Technology Stack section. Replace the
[CHOOSE] placeholders with the actual values:
For Godot:
- **Engine**: Godot [version]
- **Language**: GDScript (primary), C++ via GDExtension (performance-critical)
- **Build System**: SCons (engine), Godot Export Templates
- **Asset Pipeline**: Godot Import System + custom resource pipeline
For Unity:
- **Engine**: Unity [version]
- **Language**: C#
- **Build System**: Unity Build Pipeline
- **Asset Pipeline**: Unity Asset Import Pipeline + Addressables
For Unreal:
- **Engine**: Unreal Engine [version]
- **Language**: C++ (primary), Blueprint (gameplay prototyping)
- **Build System**: Unreal Build Tool (UBT)
- **Asset Pipeline**: Unreal Content Pipeline
After updating CLAUDE.md, create or update .claude/docs/technical-preferences.md with
engine-appropriate defaults. Read the existing template first, then fill in:
For Godot (GDScript):
PlayerController)move_speed)health_changed)player_controller.gd)PlayerController.tscn)MAX_HEALTH)For Unity (C#):
PlayerController)MoveSpeed)_moveSpeed)TakeDamage())PlayerController.cs)For Unreal (C++):
A for Actor, U for UObject, F for struct)MoveSpeed)TakeDamage())b prefix (e.g., bIsAlive)PlayerController.h)[TO BE CONFIGURED] with a suggestion:
"Typical targets: 60fps / 16.6ms frame budget. Want to set these now?"
Present the filled-in preferences to the user:
"Here are the default technical preferences for [engine]. Want to customize any of these, or shall I save the defaults?"
Wait for approval before writing the file.
Check whether the engine version is likely beyond the LLM's training data.
Known approximate coverage (update this as models change):
Compare the user's chosen version against these baselines:
LOW RISK — reference docs optional but recommendedMEDIUM RISK — reference docs recommendedHIGH RISK — reference docs requiredInform the user which category they're in and why.
Create a minimal docs/engine-reference/<engine>/VERSION.md:
# [Engine] — Version Reference
| Field | Value |
|-------|-------|
| **Engine Version** | [version] |
| **Project Pinned** | [today's date] |
| **LLM Knowledge Cutoff** | May 2025 |
| **Risk Level** | LOW — version is within LLM training data |
## Note
This engine version is within the LLM's training data. Engine reference
docs are optional but can be added later if agents suggest incorrect APIs.
Run `/setup-engine refresh` to populate full reference docs at any time.
Do NOT create breaking-changes.md, deprecated-apis.md, etc. — they would add context cost with minimal value.
Create the full reference doc set by searching the web:
Search for the official migration/upgrade guide:
"[engine] [old version] to [new version] migration guide""[engine] [version] breaking changes""[engine] [version] changelog""[engine] [version] deprecated API"Fetch and extract from official documentation:
Create the full reference directory:
docs/engine-reference/<engine>/
├── VERSION.md # Version pin + knowledge gap analysis
├── breaking-changes.md # Version-by-version breaking changes
├── deprecated-apis.md # "Don't use X → Use Y" tables
├── current-best-practices.md # New practices since training cutoff
└── modules/ # Per-subsystem references (create as needed)
Populate each file using real data from the web searches, following the format established in existing reference docs. Every file must have a "Last verified: [date]" header.
For module files: Only create modules for subsystems where significant changes occurred. Don't create empty or minimal module files.
Update the @ import under "Engine Version Reference" to point to the
correct engine:
## Engine Version Reference
@docs/engine-reference/<engine>/VERSION.md
If the previous import pointed to a different engine (e.g., switching from Godot to Unity), update it.
For the chosen engine's specialist agents, verify they have a "Version Awareness" section. If not, add one following the pattern in the existing Godot specialist agents.
The section should instruct the agent to:
docs/engine-reference/<engine>/VERSION.mdIf invoked as /setup-engine refresh:
docs/engine-reference/<engine>/VERSION.md to get
the current engine and versionAfter setup is complete, output:
Engine Setup Complete
=====================
Engine: [name] [version]
Knowledge Risk: [LOW/MEDIUM/HIGH]
Reference Docs: [created/skipped]
CLAUDE.md: [updated]
Tech Prefs: [created/updated]
Agent Config: [verified]
Next Steps:
1. Review docs/engine-reference/<engine>/VERSION.md
2. [If from /brainstorm] Run /map-systems to decompose your concept into individual systems
3. [If from /brainstorm] Run /design-system to author per-system GDDs (guided, section-by-section)
4. [If from /brainstorm] Run /prototype [core-mechanic] to test the core loop
5. [If fresh start] Run /brainstorm to discover your game concept
6. Create your first milestone: /sprint-plan new