Unity Game Skills

A canonical collection of agent skills for building casual iOS games in Unity 6 with GPT 5.6/Codex or Claude Code. Both hosts consume the same SKILL.md; OpenAI-specific discovery metadata lives in each skill's agents/openai.yaml. The skills drive a live Unity Editor through MCP for Unity, generate source assets, and enforce production gates for graphics, UI, gameplay, monetization, QA, and App Store release.

Think of it as a studio-in-a-box: one entrypoint skill (unity-game-director) that orchestrates a dozen specialists so you can go from "build me a one-tap arcade game" to a real, playable, screenshot-verified slice — without hand-picking which skill to use.

Scope. These skills target casual / hyper-casual iOS games on Unity 6 (6000.x). Most of the workflow knowledge generalizes to other Unity targets, but iOS build/release/monetization specifics are iOS-first.

---

Table of contents

• What is an Agent Skill?
• Skill catalog
• How the skills fit together
• Prerequisites
• Installation
• Environment variables
• MCP for Unity setup
• Quick start
• Prompting guide
• Repository layout
• Troubleshooting
• Contributing
• Security
• License & disclaimer

---

What is an Agent Skill?

An agent skill is a folder containing a SKILL.md file plus optional references/, scripts/, and host metadata. The YAML frontmatter contains only name and description; the host reads the description to decide when to load the instructions.

unity-graphics/
├── SKILL.md                 # frontmatter (name + description) + the playbook
├── agents/openai.yaml       # GPT/Codex UI and invocation metadata
├── references/              # deeper docs loaded on demand
│   ├── urp-mobile-recipes.md
│   └── checklists/...
└── scripts/                 # optional helper scripts the skill can run

The skills/ tree is host-neutral and is the only source of truth. Platform manifests describe installation requirements; the installer copies or symlinks the canonical directories without forking their instructions.

---

Skill catalog

Orchestration

Skill	What it does
unity-game-director	Primary entrypoint. Detects your Unity version, routes work through gameplay → graphics → UI → audio → assets → debug → QA, and verifies a real playable slice (Play Mode tests + screenshots) instead of stopping at design docs. Start here.

Execution layer (Unity Editor control)

Skill	What it does
unity-mcp-bridge	The execution layer beneath everything else. Wraps MCP for Unity to create scenes, GameObjects, components, prefabs, materials and scripts; run Play Mode / tests; read the console; drive headless iOS builds. Covers setup and the domain-reload reconnect dance.
unity-mcp-skill	Tool/resource reference and workflow patterns for the MCP for Unity server. Complements unity-mcp-bridge with schemas and best practices.

Foundations

Skill	What it does
unity-project-setup	Project foundation for a team — Unity .gitignore + Git LFS + meta-file/serialization discipline, Assets/<Game>/ structure, asmdef architecture (engine-free Core/Game/Editor/Tests), package management, versioning, secrets-per-environment, and CI/CD basics.

Design & systems

Skill	What it does
unity-game-economy	Designs the economy & meta-progression that make a casual game retain and monetize — soft/hard currencies, balanced sources & sinks, progression pacing, reward schedules, session design, and IAP-catalog/pricing design. Complements unity-monetization (wiring) and unity-analytics-liveops (measuring).

Build the game

Skill	What it does
unity-gameplay-systems	First-playable-slice scaffolding, C# architecture, Input System touch controls, scene/prefab assembly, scoring/spawning/pooling, difficulty curves, and game-feel juice (squash-stretch, screen shake, hit-stop, haptics).
unity-card-games	Card, deck, hand, lane, drag/drop, targeting, rule-model, AI-turn, and card-view lifecycle patterns with EditMode/PlayMode verification.
unity-graphics	Takes a flat/primitive scene to a premium look: URP setup, mobile lighting (baked + probes), materials/shaders, post-processing, and draw-call/overdraw budgets.
unity-aaa-graphics	Visual-quality enforcement layer. Turns flat/"programmer-art" scenes into premium, store-quality visuals: art-direction critique, a mandatory per-surface asset-sourcing decision (generate real art for terrain, paths, units, props — not flat fills), an AAA prompt library with genre art kits, render polish, and a visual scorecard that fails amateur output.
unity-art-direction	The art-direction system: a locked machine-readable art-spec.yaml single-source-of-truth, a 12-preset style library (concrete starting points), mobile art budgets (tri/texture/material caps), and a disciplined golden-asset → family production pipeline (concept → turnaround → 3D → cleanup → prefab → validation-scene → quality-gate scoring) so you ship an art-directed game, not a folder of pretty assets.
unity-asset-pipeline	The production gate between generated source art and game-ready runtime prefabs: per-asset asset-contract.yaml, sprite/mesh/import/vision QA, contract-driven Unity import, Import Presets/AssetPostprocessor defaults, SpriteAtlas/Addressables metadata, prefab factory, BeautyCell visual-regression screenshot, and an approved-asset registry that scene builders must use instead of raw generated files.
unity-scene-composition	Screen-space visual hierarchy beyond grid/layout correctness: camera profile, layers, focal path, big/medium/small shape rhythm, prop density, color zoning, occlusion budget, shadow/contact rules, and screenshot acceptance for BeautyCell/golden screens.
unity-game-layout	Board/grid/world-coordinate discipline for mechanically correct levels: coordinate systems, tile/cell sizing, path/board geometry, placement constraints, and validation of gameplay layout before visual composition.
unity-animation	Makes assets move — AAA, gameplay-synced animation via 2D sprite sheets or 3D skeletal (Tripo) rigs. Per-role clip catalog (idle/move/attack/hit/death; tower idle/aim/fire), Unity Animator/state-machine/blend-tree wiring, and Animation Events that fire gameplay on the right frame (release the arrow on the loose frame). A static asset where motion is expected fails the bar.
unity-ui-designer	Screenshot-proven mobile UI: HUDs, menus, pause/win/lose/settings screens, safe-area/notch handling, 44pt touch targets, TextMeshPro, uGUI and UI Toolkit.

Assets (generative)

Skill	What it does	API
unity-pixel-art	Pixel-native final sprites, tilesets, icons, directional sheets, and animation strips using an anchor-first workflow → imported with Point/no-compression/pixel-perfect settings.	PixelLab
unity-image-generator	Gemini exploratory/concept art, static non-pixel sprites, backgrounds, UI art, icons, particle/texture references → imported as Unity sprites/textures.	Google Gemini
unity-3d-generator	Text-to-3D and image-to-3D game-ready GLB/FBX (characters, props, vehicles, obstacles), auto-rig + animation, low-poly/mobile optimization → imported via ModelImporter.	Tripo
unity-audio-generator	SFX, looping ambience/music beds, UI sounds, and voice/TTS → imported as AudioClips with mobile-correct compression.	ElevenLabs
unity-asset-designer	Art-direction layer above the generators: style guide / art bible, character turnaround sheets, and icon sets so all generated art stays on-model. No API key of its own.

Ship it

Skill	What it does
unity-debug-profiler	Evidence-driven debugging (compile errors, NullReference, pink materials, blank scenes) and profiling (frame rate, draw calls, GC, texture memory, IL2CPP stripping).
unity-monetization	Ads integration: Google AdMob and Unity Ads direct, frequency-capped interstitials, rewarded ads, ATT + SKAdNetwork, and an SDK-agnostic ads facade.
unity-analytics-liveops	Analytics & liveops: D1/D7/D30 retention and ARPDAU funnels, remote config + A/B testing, crash/analytics SDKs (Unity Gaming Services, GameAnalytics, Firebase), soft-launch measurement, and iOS ATT/SKAdNetwork/AdAttributionKit + privacy-manifest coordination — the levers that turn a playable game into a retentive, monetizable one.
unity-qa-release	Play Mode / EditMode tests, device-resolution & safe-area checks, iOS build (IL2CPP/ASTC/Xcode), privacy manifest, TestFlight, fastlane signing, and release-risk reports.
unity-ios-secure-backend	Anti-cheat leaderboards: Apple Game Center identity verification + App Attest, verified server-side by a Node/NestJS backend.

Global & growth

Skill	What it does
unity-localization	Ship a globally-localizable game with the Unity Localization package — String/Asset Tables, locale selection, Smart Strings (plurals/variables), per-script fonts + RTL, pseudolocalization, text-expansion layout, and localized App Store metadata.
unity-aso-growth	App Store Optimization & growth — icon/title/keywords/screenshots/preview-video, Apple Product Page A/B testing, creatives & soft-launch UA, SKAdNetwork/AdAttributionKit measurement, and ratings prompts. Retention before acquisition.

---

How the skills fit together

                          ┌─────────────────────┐
   "build me a game"  ──▶ │  unity-game-director │  (orchestrator)
                          └──────────┬──────────┘
            ┌──────────────┬─────────┼─────────┬──────────────┐
            ▼              ▼         ▼          ▼              ▼
      gameplay-      graphics /   asset-     monetization   qa-release /
      systems          ui       designer                   debug-profiler
            │              │         │                          │
            │              │   ┌─────┴─────┐                    │
            ▼              ▼   ▼     ▼      ▼                    ▼
         ┌──────────────────────────────────────────┐    iOS build / tests
         │            unity-mcp-bridge               │◀──────────┘
         │   (drives the live Unity 6 Editor)        │
         └──────────────────────────────────────────┘
              ▲                              ▲
        image / 3d / audio            MCP for Unity
        generators (APIs)             (Editor package)

You normally only need to talk to unity-game-director — it loads the rest as needed. Every concrete change goes through unity-mcp-bridge, which talks to a live, open Unity Editor (not files on disk).

---

Prerequisites

Requirement	Why	Notes
Codex/GPT 5.6 or Claude Code	Runs the skills	Pick either supported host; install commands are below.
Unity 6 (6000.x) Editor	The game engine these skills target	6000.5 LTS or newer recommended
MCP for Unity (com.coplaydev.unity-mcp)	Lets the agent drive the Editor	Installed as a Unity package — see MCP setup
Python 3.10+ and uv	MCP for Unity server + asset scripts	uv is required by the MCP server
Xcode (macOS)	iOS builds / TestFlight	Only needed when you build for device
API keys (optional)	Generative asset skills	Only for the generator you use — see env vars

The core gameplay/graphics/UI/QA skills work without any API keys. Keys are only needed for the generative asset skills (image / 3D / audio).

---

Installation

Clone once, then use the platform-aware installer. Symlink mode is the default so git pull updates both hosts without stale copies.

GPT 5.6 / Codex

Available in every project on your machine:

git clone https://github.com/tea-x-random/unity-game-skills.git
cd unity-game-skills
python3 scripts/install_skills.py --platform openai --force
export UNITY_GAME_SKILLS_HOME="${CODEX_HOME:-$HOME/.codex}/skills"

This installs to ${CODEX_HOME}/skills when CODEX_HOME is set, otherwise ~/.codex/skills. Every skill includes agents/openai.yaml for GPT/Codex discovery and UI metadata.

Claude Code

cd unity-game-skills
python3 scripts/install_skills.py --platform claude --force
export UNITY_GAME_SKILLS_HOME="$HOME/.claude/skills"

This installs to ~/.claude/skills.

Custom, copied, or partial installs

python3 scripts/install_skills.py --platform openai --mode copy --destination /path/to/skills --force
python3 scripts/install_skills.py --platform claude --skill unity-game-director --skill unity-mcp-bridge --force

Verify

Run the repository validator, then start the chosen host and ask: "What Unity skills do you have?"

python3 scripts/validate_repository.py

You don't need all 27. Install only the ones you want (e.g. unity-game-director, unity-mcp-bridge, unity-gameplay-systems, unity-graphics, and unity-ui-designer for an asset-key-free workflow).

Always install whole skill directories, never individual scripts. Several scripts import sibling modules — e.g. unity-image-generator/scripts/generate_image.py, validate_sprite.py, and critique_image.py all import art_spec.py and fail without it. Re-run the installer to refresh copied installations.

---

Environment variables

Only the generative asset skills need keys. Set them in the shell environment that launches your chosen host.

Variable	Used by	Get a key	Required?
TRIPO_API_KEY	unity-3d-generator	platform.tripo3d.ai	Only for 3D generation / non-pixel pre-render
GEMINI_API_KEY	unity-image-generator	Google AI Studio	Only for Gemini exploration / non-pixel 2D image generation
PIXEL_LABS_API_KEY	unity-pixel-art	pixellab.ai/docs	Only for final pixel-art generation
ELEVENLABS_API_KEY	unity-audio-generator	elevenlabs.io	Only for audio/voice generation

Copy .env.example and fill in what you need, then export the values. The simplest reliable approach is to add them to your shell profile (~/.zshrc or ~/.zprofile on macOS):

export TRIPO_API_KEY="your-tripo-key"
export GEMINI_API_KEY="your-gemini-key"
export PIXEL_LABS_API_KEY="your-pixellab-key"
export ELEVENLABS_API_KEY="your-elevenlabs-key"

Then source ~/.zshrc (or open a new terminal) before launching the agent host.

The skills resolve keys in this order: an explicit --api-key flag → the environment variable above. unity-game-director ships a probe script that reports SET / MISSING for each key without ever printing the value.

Never commit real keys. .env is git-ignored. These keys bill against your third-party accounts — treat them like passwords.

---

MCP for Unity setup

The skills change your project by driving a live Unity Editor through the MCP for Unity server (CoplayDev). High-level steps (the unity-mcp-bridge skill covers this in detail):

1. Install the Unity package — in Unity: Window → Package Manager → Add package from git URL → https://github.com/CoplayDev/unity-mcp.git, or via OpenUPM: openupm add com.coplaydev.unity-mcp.
2. Register the MCP server with your agent host. For Claude Code:

   claude mcp add unity --transport http http://127.0.0.1:8080/mcp

3. Start the bridge — in Unity: Window → MCP for Unity → Start/Connect until it reads Connected (needs uv / Python 3.10+ on PATH).
4. Keep the Editor open and focused. MCP talks to the running Editor; after every C# compile or package change Unity does a ~5s domain reload that briefly drops the connection — the skills know to wait and reconnect.

---

Quick start

With skills installed, MCP connected, and your Unity 6 project open:

You: Build me a one-tap endless runner prototype — cute low-poly fox dodging
     obstacles, score counter, game-over screen. Make it a real playable slice.

The agent (via unity-game-director) will roughly:

1. Detect the Unity version and project capabilities.
2. Pin a tiny scope + aesthetic north-star, asking one batched round of questions if needed.
3. Scaffold gameplay (unity-gameplay-systems) through MCP — input, spawning, scoring, game loop.
4. Lock screen composition (unity-scene-composition) — camera, layers, focal path, density, color zones, and BeautyCell target.
5. Generate source art if you have keys (unity-pixel-art for final pixel sprites/sheets, unity-3d-generator for 3D or non-pixel pre-rendered actors, unity-image-generator for Gemini concepts/UI/reference), or use procedural placeholders if not.
6. Promote generated files through unity-asset-pipeline — asset contracts, sprite/mesh/import QA, prefab factory, BeautyCell screenshot, and approved-asset registry.
7. Build the HUD and game-over screen (unity-ui-designer).
8. Polish visuals (unity-graphics).
9. Run Play Mode and capture screenshots (unity-qa-release / unity-debug-profiler) as evidence it actually runs.

You stay in control — review each phase, redirect, or ask for changes.

See the Prompting guide for how to get the best results. Maintainers can use External benchmark workflow to periodically fold popular/official Unity production practices back into the skills.

Designing for quality, retention & monetization

• Ask for real generated art on every surface, not flat placeholders — terrain, paths, units, and props should be sourced art, not solid fills. The unity-aaa-graphics skill enforces this with a per-surface asset-sourcing decision and a visual scorecard.
• Pin an art-direction north-star early — palette, style, and finish (flat vs glossy) — so every asset and screen stays on-model instead of drifting.
• Pixel art → PixelLab, Gemini → exploration, Tripo → 3D/non-pixel motion. Final pixel sprites/sheets should be generated pixel-native with unity-pixel-art / PixelLab, not 3D renders downscaled into pixels. Gemini is for concepts, static non-pixel art, textures, UI, and reference images; Tripo is for runtime 3D and high-res/painterly pre-rendered actors.
• Treat generated art as source, not final assets. Promote source files through unity-asset-pipeline: preserve/validate alpha, enforce import settings, generate prefabs, record BeautyCell screenshots, and enter only approved prefabs into the registry.
• Compose before scaling. Use unity-scene-composition to build one BeautyCell/golden screen before generating dozens of assets; fix camera, scale, focal path, density, and color zoning there first.
• Adopt proven Unity production gates. The asset pipeline now tracks SpriteAtlas groups, Import Presets/AssetPostprocessor defaults, optional Addressables labels, and optional URP 2D secondary textures so popular Unity best practices become contract fields and validators, not tribal memory.
• Use best-of-N generation for production art. Inspired by image-extension workflows, unity-image-generator can now generate multiple candidates, run pixel + vision QA, select the best with select_best_candidate.py, and extrude/pad sprite or tile sheets with extrude_atlas.py before Unity import.
• Design for hybrid monetization (ads + IAP). Only ~1.8% of players ever buy an IAP, so rewarded/interstitial ads carry most casual revenue — plan both, not one.
• Instrument retention (D1/D7/D30) and tune via remote config / A/B testing rather than guessing. The unity-analytics-liveops skill covers the funnels, SDKs, and experiments.

---

Prompting guide

A short version (full guide in docs/PROMPTING.md):

• State the genre and one core mechanic. "hyper-casual stacker", "match-3 with a swap-and-cascade board", "one-tap flappy-style runner." Specific beats vague.
• Name your constraints up front. Target device, portrait vs landscape, art style, "no API keys / use procedural art," and whether you want a prototype or a release-ready slice.
• Ask for a real, verified slice. Add "make it actually playable and show me screenshots / Play Mode results" to push past design-doc answers.
• Let the director pick skills. You rarely need to name a skill; describe the outcome. If you do want a specific one, say e.g. "use the monetization skill to add a rewarded ad."
• Provide an aesthetic north-star early — a reference style, a 4–7 color palette, one font, flat-vs-glossy. This is the single biggest lever on visual quality and avoids endless re-guessing.
• Batch your decisions. Answer concept/art/scope questions in one go so the agent can keep moving.

---

Repository layout

.
├── README.md
├── LICENSE                  # MIT
├── CONTRIBUTING.md
├── SECURITY.md
├── .env.example
├── .gitignore
├── AGENTS.md                # GPT/Codex repository guidance
├── CLAUDE.md                # Claude entrypoint to the shared guidance
├── platforms/               # host manifests; never duplicated skill bodies
├── scripts/                 # installer + repository validator
├── tests/                   # deterministic pipeline tests
├── docs/
│   ├── PROMPTING.md
│   └── EXTERNAL_BENCHMARK_WORKFLOW.md
└── skills/
    ├── unity-game-director/
    ├── unity-mcp-bridge/
    ├── unity-mcp-skill/
    ├── unity-gameplay-systems/
    ├── unity-card-games/
    ├── unity-graphics/
    ├── unity-aaa-graphics/
    ├── unity-art-direction/
    ├── unity-asset-pipeline/
    ├── unity-scene-composition/
    ├── unity-game-layout/
    ├── unity-animation/
    ├── unity-ui-designer/
    ├── unity-pixel-art/
    ├── unity-image-generator/
    ├── unity-3d-generator/
    ├── unity-audio-generator/
    ├── unity-asset-designer/
    ├── unity-debug-profiler/
    ├── unity-monetization/
    ├── unity-analytics-liveops/
    ├── unity-qa-release/
    ├── unity-ios-secure-backend/
    ├── unity-project-setup/
    ├── unity-game-economy/
    ├── unity-localization/
    └── unity-aso-growth/

---

Troubleshooting

Symptom	Likely cause	Fix
Host doesn't use the skills	Wrong install target or stale copy	Re-run scripts/install_skills.py --platform openai|claude --force, then restart the host.
"no Unity session" / MCP not responding	Editor closed, unfocused, or mid domain-reload	Focus the Unity Editor; wait ~5s after a compile; re-check Window → MCP for Unity reads Connected
*_API_KEY=MISSING	Key not exported in the shell that launched the host	Add to ~/.zshrc/~/.zprofile, source it, relaunch the host.
Image script fails to import google-genai	macOS system Python is externally managed (PEP 668)	The skill creates a venv: python3 -m venv .artvenv && .artvenv/bin/pip install google-genai pillow
Pink/magenta materials in scene	Wrong render pipeline / missing shader	Ask unity-debug-profiler; usually a Built-in↔URP material mismatch
New AdMob/Unity Ads serves no real ads	Brand-new ad unit is pending approval (no-fill)	Expected — only the SDK's test unit IDs serve until approved

---

Contributing

Contributions are welcome — see CONTRIBUTING.md. In short: keep skills evidence-driven and concise, never commit secrets or project-specific identifiers, and test changes against a real Unity 6 project before opening a PR.

---

Security

• These skills run scripts and drive your Unity Editor locally. Review what they do before granting broad permissions.
• API keys bill against your third-party accounts. Keep them in your environment, never in the repo.
• Found a sensitive value in a skill or a security issue? See SECURITY.md.

---

License & disclaimer

Licensed under the MIT License.

This is an independent, community project. It is not affiliated with or endorsed by Unity Technologies, Apple, Google, Tripo, ElevenLabs, CoplayDev, or Anthropic. "Unity," "iOS," "App Store," "Game Center," "AdMob," "Gemini," and other names are trademarks of their respective owners. The generative skills call third-party APIs that have their own terms, pricing, and content policies — you are responsible for your usage and any costs incurred.