skill

unikit-ai

The AI Development Pipeline for Games: design, code, and the engine editor

NintendaDev/unikit-aicommunitylistedunreviewed

Set up

Skills are installed by placing their folder where your agent loads skills.

Download ZIP from GitHub Open the repository

The download comes from github.com/NintendaDev/unikit-ai itself, not from our server, so what you get is exactly what its author published.

Install instructions come from the README

Skills do not use an MCP config. Follow the steps in the README below.

README

synced Oct 17, 2026

UniKit AI

The AI Development Pipeline for Games: design, code, and the engine editor

Building a game with AI usually breaks in the same place: the agent writes a class, and then stops. The design lives in someone's head, the scene lives in the editor, and neither is something a prompt can reach. UniKit AI closes that gap - it authors the game design, plans and writes the code against a memory of your engine and stack, and carries the same plan into the engine editor through the engine's MCP server. An engineered pipeline instead of vibe-coded prompts.

Why UniKit AI?

Spec-driven development cycle - explore the idea, plan, implement, review, verify, document. Each step reads the artifact the previous one wrote: no prompt engineering, no re-explaining the project every session, and a plan you can read and correct before a line is written. Predictable enough that a small model can execute a plan a large one made
Almost the whole cycle, not just the code - design the game, write the code, work in the editor. One pipeline covers all three, and a single plan can mix code tasks with editor tasks
The engine MCP is used to the full, and checked - the agent gets real-time feedback from the running editor: console, compilation errors, test runs, editor state. Every result is read back from the editor rather than taken from the server's response
Framework rules out of the box - ready-made rules for engine modules and popular frameworks from the official registry. Plug in your own Git registry to carry a private rule library across projects, or generate fresh rules from your codebase on the fly
Dynamic memory - one memory for all engine frameworks instead of a separate skill per library. Core rules are always loaded, stack rules are pulled in by task context - saving tokens and keeping the context window lean
Self-learning memory - the agent turns bug fixes and code reviews into patches, then distills them into improved project rules. The system gets smarter with every fix

Scope

UniKit AI covers three layers of game development:

Layer	What it covers
Game design	concept, pillars, systems, flows, content schemas - a machine-readable design that code plans read from
Game code	architecture, systems, tests, refactoring, review, documentation
Engine editor	scenes, prefabs, UI, materials, animation, assets, project settings - planned as explicit tasks, executed through the engine MCP

Editor work is a first-class part of a plan, not an afterthought: it is planned next to the code, carried out through the engine MCP and verified by reading the result back from the editor. See Editor tasks.

Art production, audio authoring, and store/build pipelines are not covered.

Supported Engines

Each engine ships one or more MCP servers. Where several are listed, they are alternatives - unikit-ai init offers them as a choice and the first one is the default. The versions are each vendor's own minimum, and UniKit AI does not detect your engine version, so check yours before accepting the default.

Engine	MCP servers (in wizard order)
Unity	Unity Biome MCP (Unity 6000.0+) · Coplay Unity MCP (Unity 2021.3 LTS+)
Godot 4 / Godot 4 .NET	Fennara Godot AI - free (Godot 4.5+) · GDAI Godot MCP - paid (Godot 4.1+) · Coding-Solo Godot MCP - free (no declared minimum)
Unreal Engine 5	ChiR24 Unreal MCP (Unreal Engine 5.0+)

See Configuration for how UniKit AI works with each server.

Supported Agents

Agent	Config Directory	MCP Support
Claude Code	`.claude/`	Yes (`.mcp.json`)
Codex CLI	`.codex/`	Yes (`.codex/config.toml`)
Cursor	`.cursor/`	Yes (`.cursor/mcp.json`)
Qwen Code	`.qwen/`	Yes (`.qwen/settings.json`)
OpenCode	`.opencode/`	Yes (`opencode.json`)
Antigravity	`.agents/`	Yes (`.agents/mcp_config.json`)
Kimi Code	`.kimi-code/`	Yes (`.kimi-code/mcp.json`)
Universal / Other	`.agents/`	Yes (`.mcp.json`)

Select one or more during unikit-ai init. See Agents for agent-specific caveats.

Installation & Quick Start

npm install -g unikit-ai    # install
unikit-ai update            # later: reinstall only what changed in the project

unikit-ai init              # in your game project directory

The wizard asks which AI agent you use and which game engine, configures the MCP servers, and installs the skills, subagents and engine templates.

Context7 is also recommended - the agent uses it for generating framework rules and deep research of libraries and APIs.

Then open your AI agent and start working:

/unikit

/unikit scans your game project, detects the full tech stack, asks targeted questions to fill in gaps, generates project description and architecture files, then bootstraps starter rules for every framework in your stack so the agent is ready to write idiomatic code from the first prompt.

Example Workflow

Say you want to add an item rarity system with visual effects.

1. Explore - research the idea, analyze the codebase, find integration points:

/unikit-explore Add item rarity system with rarity tiers and drop logic

The agent produces a research document with diagrams, option comparisons, and architectural recommendations. Save it or feed it directly into the next step.

2. Plan - turn research into concrete tasks:

/unikit-plan

The plan carries both code tasks and, where the feature needs them, editor tasks - the rarity badge on the item widget, the tint material, the VFX prefab.

3. Improve - refine the plan (run 2-3 times for complex features):

/unikit-improve

4. Implement - execute tasks phase by phase, code and editor alike, test in-game after each one:

/unikit-implement

5. Review & Verify - check code against project rules, verify completeness:

/unikit-review

/unikit-verify

6. Commit:

/unikit-commit

7. Pull request (optional) - open the branch's PR, or print its text when the GitHub MCP is not set up:

/unikit-pr

See the full Development Workflow with diagram and decision table.

How It Works

  explore ──▶ plan ──▶ improve ──▶ implement ──▶ review ──▶ verify ──▶ commit
               │                       │                                 │
         design brief         code + editor tasks      fix ──▶ patch ────┤
                              through the engine MCP                     │
                                                                         │
                                     evolve ◀────────────────────────────┘
                           distill patches into rules

The development loop runs through exploration, planning, implementation, and review. Plans pull a design brief from the game design when there is one, execute code and editor work through the same pipeline, and bug fixes along the way generate patches that feed into the evolution step - distilling real project experience into permanent rules.

Dynamic Memory and Remote Rules Registry

Every code task runs through a two-tier knowledge base: core rules are always loaded (code style, design principles, performance, testing), stack rules are loaded only when the task needs them (DI, async, reactive, UI, etc.). Rules come from the official remote registry, versioned independently of the npm package, and you can connect your own private registry to carry your team's rule library across projects.

→ Dynamic Memory · Rules Registry

Game Design

Beyond code, UniKit AI helps author the game design itself, so that planning starts from a written design instead of a prompt:

Ideate and research - brainstorm a concept, check the market and references
Author - the one-page game overview, then systems, player flows and content schemas
Review and verify - a qualitative review and a consistency check of the whole design
Start from existing code - reconstruct design facts from a project that has no design document yet
Genre starters - a bundled catalog of genre profiles seeds a new design
Read it as a document - render the design into human-readable docs

The design feeds code plans, and code never edits it, with one exception: once /unikit-verify confirms a feature is done, the design is marked as implemented.

→ Game-Design Module

Self-Learning

Every bug fix and code review creates a patch - a record of what went wrong and how it was fixed. When patches accumulate, /unikit-evolve analyzes them and distills patterns into project rules.

  bug found ──▶ /unikit-fix ──▶ patch created ──▶ /unikit-evolve ──▶ new rule
                                                                        │
                                                          next session uses it

The agent doesn't repeat the same mistakes: the more you fix and evolve, the smarter the framework becomes for your specific project.

→ Memory & Skill Evolution

UniKit AI works alongside any other AI framework - it uses its own config directory and never touches standard agent files like CLAUDE.md or .cursorrules.

Documentation

Guide	Description
Getting Started	What is UniKit AI, CLI commands, first project
Help Navigator	Not sure which skill to use? Start here
Agents	Supported AI agents and their known limitations
Best Practices	Practical tips for working with the agent
Development Workflow	Workflow diagram, skill pipeline, spec-driven approach
Skills Reference	All 35 skills - 24 code-pipeline + 11 game-design
Subagents	Coordinators, workers and sidecars
Plan Files	Plans, editor tasks, patches
Game-Design Module	Game design authoring and genre profiles
Dynamic Memory	Core and stack rules, the memory pipeline
Memory & Skill Evolution	How fix patches turn into rules
Configuration	Project config, MCP servers, project structure
Rules Registry	Remote rules registry and its CLI commands
Extensions	Third-party skills, injections, MCP servers