From qq
Generates Unity implementation plans from game design docs or briefs, outputting Mermaid architecture, key types, interfaces, and ordered steps with file paths.
How this skill is triggered — by the user, by Claude, or both
Slash command
/qq:planThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Respond in the user's preferred language (detect from their recent messages, or fall back to the language setting in CLAUDE.md).
Respond in the user's preferred language (detect from their recent messages, or fall back to the language setting in CLAUDE.md).
Generate a technical implementation plan for Unity. This is NOT a game design document — it translates an existing design into an engineering plan that /qq:execute can consume.
When the plan can use live Unity editing instead of code: some implementation steps are simpler as direct tykit calls (scene tweaks, prefab overrides, UI adjustments, one-off data fixes) rather than writing C# utilities. If a step is a one-shot editor-state change, see
shared/tykit-reference.mdand mark the step as "execute via tykit command X" in the plan. Reserve code-writing for changes that need version control, compile-time validation, or repeatable behavior.
Arguments: $ARGUMENTS
Best case: user provides a game design document (from Docs/qq/, Docs/design/, Notion export, or inline). Read it fully, extract the technical requirements.
Minimal case: user gives a one-liner like "add a health system" or "weapons need ammo reloading". Ask 3-5 targeted technical questions before proceeding:
Do NOT ask more than 5 questions. If something is unclear, explore the codebase to find the answer yourself. Prefer reading code over asking the user.
Before writing the plan, understand what already exists:
Assets/Scripts/, service modules, existing interfaces)This step is critical — do not design in a vacuum.
Output a single markdown document following this format. Keep it concise — 1-3 pages max. No filler.
# [Feature Name] — Implementation Plan
## Goal
One sentence. What technical capability is added.
## Architecture
```mermaid
graph LR
A[ComponentA] --> B[ComponentB]
B --> C[ComponentC]
| Type | Kind | Purpose |
|---|---|---|
Foo | MonoBehaviour | Does X |
Bar | ScriptableObject | Stores Y |
IFoo | interface | Contract for X |
public interface IFoo {
void DoSomething(SomeEvent e);
float Value { get; }
event Action<float> OnValueChanged;
}
Any new config fields, serialized data, or save structures. Use actual field names and types.
Ordered, each step is a shippable increment. Include:
Create IFoo interface — Assets/Scripts/Systems/IFoo.cs
Implement FooSystem — Assets/Scripts/Systems/FooSystem.cs
Wire into existing BarSystem — Assets/Scripts/Systems/BarSystem.cs
Tests — Assets/Tests/EditMode/FooSystemTests.cs
/qq:add-tests can implement this coverage without ambiguity, then all tests green
## 4. Save the Plan
Get branch name: `git branch --show-current | tr '/' '_'`
Save to `Docs/qq/<branch-name>/<feature-name>_implementation.md`.
## 5. Record Decisions
After saving the plan, record key technical decisions:
```bash
qq-decisions.py add --project . --phase plan --key "<decision>" --value "<choice>" --reason "<why>"
Record architecture choices, pattern decisions, key interface designs.
Plan review is mandatory before execution. Do NOT offer /qq:execute directly.
First, check if Codex CLI is available by running which codex 2>/dev/null || where codex 2>/dev/null.
/qq:codex-plan-review (cross-model review catches blind spots that same-model review misses)/qq:claude-plan-review--auto mode: run qq-execute-checkpoint.py pipeline-advance --project . --completed-skill "/qq:plan" --next-skill "/qq:codex-plan-review" --plan-doc "<saved-plan-path>", then run the check and invoke the appropriate review skill with --auto.
Before saving the plan, verify:
If any check fails, fix the plan before saving.
/qq:execute — ordered steps with file paths and done criteria/qq:add-tests can implement them without re-planning/qq:tech-research to search for proven approaches before committing to one in the plan.npx claudepluginhub tykisgod/quick-questionGuides video game development: brainstorm ideas, plan gameplay loops, choose engines like Unity/Godot/Three.js/Phaser, scaffold projects, add features, fix bugs, create assets.
Guides creation, editing, and verification of skills for AI coding agents using test-driven development with subagent scenarios. Use when authoring or debugging skills.