UniKit AI

AI-Powered Pipeline for Game Development: Game Design & Code

You want to build games with AI, but setting up the right context, rules, and workflows takes time. UniKit AI handles all of that across two knowledge modules - code (architecture, systems, tests - skills, dynamic memory, MCP servers for real-time engine feedback) and gamedesign (GDD authoring - concept, systems, flows, content). An engineered pipeline instead of vibe-coded prompts.

Why UniKit AI?

• Spec-driven development cycle - explore idea, plan, implement, review, generate and update documentation - without writing complex prompts, everything works through the framework's pipeline. The same pipeline extends to game design: an optional gamedesign module authors a structured GDD that code plans read from
• 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 always loaded, stack rules loaded dynamically by task context - only relevant rules are pulled in, saving tokens and keeping the context window lean
• Self-learning memory - during development the agent creates patches from bug fixes and code reviews, then distills them into improved project rules and dynamic memory. The system gets smarter with every fix
• Flexible, not rigid - full spec-driven pipeline when you need predictability, or classic prompt-based work when you need speed. In both modes the agent has the full framework memory - core rules, architecture, stack - and loads stack-specific rules dynamically
• Built for game engines, by a game developer - no generic boilerplate from general-purpose frameworks. Every skill, rule, and workflow is designed specifically for game code development with native support for each engine

Scope

UniKit AI covers two areas of game development: game code (architecture, systems, tests, refactoring) via the code module, and game design documentation (concept, systems, flows, content) via the gamedesign module.

There's no dedicated "scene" skill, but scene work isn't excluded - when a feature needs it (e.g. wiring a new controller into the scene, placing UI elements, arranging objects), /unikit-plan can add scene-configuration tasks alongside the code tasks, executed via the engine MCP server during /unikit-implement. This isn't guaranteed for every task - it depends on what the feature actually needs. Deeper asset-level workflows are on the roadmap.

Supported Engines

Supported Agents

Claude Code is the recommended agent.

• Full native support - primary development and optimization of UniKit AI are focused on Claude Code
• Advanced orchestration - only Claude Code provides full support for dev subagents and complex task orchestration

Select one or more during unikit-ai init. The wizard renders a single flat checkbox list with a right-aligned [Stable] / [Beta] tag next to each agent (stable agents listed first). Beta agents are fully wired in but rough edges are still possible. See docs/agents.md for agent-specific caveats and docs/configuration.md for configuration details.

Educational materials on YouTube (Russian)

🎞 Как мы пишем игру на Unity полностью с AI

🎞 От установки в проект Unity до первого AI коммита

🎞 Как заставить ИИ-агента перестать угадывать архитектуру для игры в Unity

🎞 От ИИ-плана до закоммиченной фичи на Unity

🎞 Память AI-агента под свой Unity проект

Installation & Updating

# install
npm install -g unikit-ai

# update the CLI package itself to the latest version from npm
unikit-ai self-update

# reinstall only what changed in the user project (hash-based detection)
unikit-ai update

# clean reinstall
unikit-ai update --force

Quick Start

unikit-ai init              # In your game project directory

This will:

• Ask which AI agent you use
• Select your game engine
• Configure MCP servers
• Install skills, subagents, and engine templates

Rules (core + stack) are installed separately by /unikit - after init finishes, run /unikit in your AI agent. It bootstraps .unikit/memory/ via the registry chain and generates stack-specific rules for whatever it finds in your project.

It's highly recommended to install an MCP server for your engine before running unikit-ai init. Engine MCP servers give the agent real-time feedback - reading console logs, catching compilation errors, and running tests - so the agent can fix issues without developer involvement. See the Supported Engines table for available MCP servers.

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

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

/unikit-improve

4. Implement - execute tasks phase by phase, 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

See the full Development Workflow with diagram and decision table.

How It Works

  explore ──▶ plan ──▶ improve ──▶ implement ──▶ review ──▶ verify ──▶ commit
                                       │                                  │
                                       │            fix ──▶ patch ────────┤
                                       │                                  │
                                       └──────────── evolve ◀─────────────┘
                                              distill patches into rules

The development loop runs through exploration, planning, implementation, and review. 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 - always loaded: code style, design principles, folder structure, performance, testing
• Stack rules - loaded dynamically: only the rules relevant to the current task context (DI, async, reactive, UI, etc.)

Rules are fetched from the official remote registry, versioned independently of the npm package. You can configure a custom or private registry to carry your team's rule library across projects.

→ Dynamic Memory · Rules Registry

Game design (GDD authoring)

Beyond code, UniKit ships a second knowledge module, gamedesign, for authoring a Game Design Document along three machine-readable axes plus the one-page whole:

Ideation (/unikit-gd-brainstorm), research (/unikit-gd-explore), and a review/verify pair (/unikit-gd-review, /unikit-gd-verify) round out the module.

A bundled genre-profile catalog (unikit-ai genres list/show/install) seeds new projects from the industry genre matrix — /unikit-gd-brainstorm infers the genre, /unikit-gd-specbest-fits it to a read-only profile and seeds the GDD.

Design ↔ code is a one-way boundary. Design writes GD-IDS.yaml; code only reads it — /unikit-plan pulls a ## Design (plus ## Flow Context / ## Content Context) brief from the registry when planning a feature, and code never edits the GDD. There is exactly one sanctioned exception: once /unikit-verify confirms every acceptance criterion is met, it stamps implemented_version back into the registry, so the next planning pass — and the GAME.md ## System Map [gen] — knows what's actually built.

  design zones ──▶ GD-IDS.yaml ──▶ plan ──▶ implement ──▶ verify
                        │                                    │
                        └──────── implemented_version ◀──────┘
                           (the one sanctioned code → design write)

→ 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 and skill-context overrides.

  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.

Learn more: Dynamic Memory | Memory & Skill Evolution

Zero conflicts with other tools

Uses its own config directory and skill format, never touches standard agent files like CLAUDE.md or .cursorrules. Works alongside any other AI framework without file or skill collisions.

Documentation

Start Here

Daily Workflow

Deep Dive

Community

• Telegram Community - chat with other users, share your rules, get quick help
• Github Discussions - deeper technical discussions and framework proposals
• Github Issues - bug reports and feature requests

Links

• Author Official Site - personal website and hub for all author's projects
• Author Telegram Channel - follow updates, roadmap previews, and dev blog posts
• Unity | Godot | Unreal Engine - Supported game engines
• UnityMCP | Godot MCP | Unreal MCP - Engine MCP servers
• Claude Code - Anthropic's AI coding agent
• Qwen Code - Alibaba's AI coding agent
• OpenCode - Open-source AI coding agent

License

MIT License. See LICENSE for details.