How We Automated Figma-to-Unity UI Integration With AI Agents | GameDev Day 2026

Summary

Alina and Olya present an AI-assisted pipeline for turning Figma designs into Unity UI. Its goal is to reduce repetitive implementation work—not replace designers or developers—particularly for long-running mobile games built with Unity UI.

How the pipeline works

The system combines a deterministic Figma-to-Unity converter with an AI agent connected through an MCP server. The converter handles predictable, common layouts, while the agent handles exceptions and follow-up corrections that would otherwise require custom code or manual work.

The architecture has two layers:

• Unity package (core): Reads a Figma frame into a tree model and processes it through customizable pipeline steps.
• MCP server (agent interface): Lets an agent read Figma layouts, create and edit prefabs, manage assets and mappings, and check project connections.

The accompanying skills cover project setup, connecting Figma and Unity assets, creating and updating prefabs, inspecting differences, and importing images.

Design-system requirements

The pipeline depends on a clear, reusable UI kit shared between Figma and Unity. The presenters describe a mapping between Figma and Unity concepts:

• Components map to prefabs.
• Variants map to prefab variants.
• Auto Layout maps to layout groups.
• Constraints map to anchors.

Components and assets are linked using stable IDs and mappings.

Their recommended design practices are:

1. Use clear, consistent names and a logical hierarchy.
2. Use reusable components and variants instead of duplicated elements.
3. Set up Auto Layout and constraints to express responsive behavior.
4. Before handoff, check for unnecessary elements, correct masks and layouts, optimized assets, and working variants.

The presenters compare a well-structured design to a good prompt: clearer input reduces agent guesswork, token use, and inconsistent results.

Creating and updating prefabs

For new screens, the agent previews the expected hierarchy, selects a pipeline, and asks the MCP server to build the prefab. The resulting prefab is returned in a compact JSON format so the agent can inspect it and fix specific problems.

For updates, the system compares an existing Unity prefab with the latest Figma mockup and applies changes to its structure and properties. This is intended to preserve existing scripts, object links, and manual fixes rather than replace the prefab wholesale.

To make prefab data easier for agents to handle, the team tested several serialization formats. They kept JSON because it works with standard parsers and Unity, then reduced its size by minifying it, shortening keys, using arrays, and removing default and null values. They report that the optimized representation is about 92% smaller than the original prefab file.

Evaluation and limitations

The presenters tested real production screens and pop-ups using four approaches: manual implementation, a converter alone, a general-purpose agent, and their combined converter-and-agent setup. They report that implementation was about four times faster on average for the screens they measured. The transcript does not provide the detailed benchmark table or exact per-approach timings.

They describe trade-offs in the alternatives:

• Manual work can introduce human error.
• Converters may miss assets or recreate existing components.
• General-purpose agents can be inconsistent, struggle with large screens, require manual corrections, or break script references.

Their approach is not fully autonomous and still requires human review in some cases.

Practical guidance and Q&A

• Figma access: Dev Mode is required for their setup. The presenters say the free Figma version has limits on API requests.
• Legacy projects: The tool was developed for existing Unity UI projects and is intended to work with them.
• Unity UI Toolkit: Agents can create interfaces in UI Toolkit without MCP, though the presented pipeline targets existing Unity UI workflows.
• Responsive layouts: The team had not yet tested the automation’s adaptability across different device sizes.
• Editing direction: Figma is the source of truth. Changes made in Unity are not intended to flow back into Figma; Unity updates are requested by asking the agent to apply Figma changes.
• Extensibility: Teams can create their own skills to check layouts, find inconsistencies, remove unnecessary elements, and automate corrections.
• Availability: The presenters say the repository is open and free to use and adapt.

Main speakers and sources

• Alina Chupakhina — Unity developer; presented the Unity pipeline, implementation, and evaluation.
• Olya Chupakhina — UI/UX designer; presented the design system and Figma workflow.
• JetBrains GameDev Day 2026 hosts and moderators — Introduced the talk and facilitated the Q&A.