5 tips for using GitHub Copilot with Unity

With Unity’s AI tools now available in beta, we’re seeing a lot of excitement around its new features, namely the in-Editor AI assistant and its integrations with popular developer tools. If you’re new to the beta, you can learn more on the AI tools web page. We’ve also created a video tutorial series to help you get started with its core features.

We sat down with Stacey Haffner to discuss how she uses GitHub Copilot with Unity to optimize her game development workflows. Stacey is a former principal developer advocate at Microsoft, as well as a YouTuber with more than a decade of experience as an independent game developer. Her background spans creator technology across .NET, Xbox, and Unity. When she isn't advocating for developers, she manages her own indie studio and publishes bi-weekly game development tutorials.

Let’s dive in.

Tip 1: Work with the context window, not against it

“The context window is the AI's working memory for a session which has a limit. Depending on which underlying model is being used, performance can start to degrade before it even reaches its limit, so responses can become less accurate as a session goes on. GitHub Copilot helps with this by letting you compact a session, but if you trigger compaction after the underlying model has already started to degrade, the degraded state becomes your new baseline. That's why I recommend structuring your workflow around this limit from the start.”

“For more complex features, I use the main chat thread to orchestrate that work. For a big feature, I’ll have the main thread break the work into focused chunks, then start up background agents to handle each one. A coding agent handles the implementation, a validation agent reviews it, and once the review passes, the cycle repeats until the feature is done. Each agent works in its own context, so the main thread stays focused and performs consistently for longer.”

Tip 2: Set up the project environment

“The underlying models powering GitHub Copilot are typically generalist, but you can customize Copilot’s behavior by adding configuration files to the .github folder in your project. You can add three main file types to help GitHub Copilot understand your project and your domain.”

• Custom Instructions are always-on context that Copilot loads for every session that defines your project’s baseline. They should include your preferred coding conventions, Unity project specifications (for example, Unity Engine version and rendering pipeline), architecture patterns, and general preferences. Use these for things that should always be true regardless of which part of the project you're working on.
• Agents are domain expert personas, each with their own dedicated tools and instructions. I have agents focused on shaders, UI Toolkit, game systems, and so on. At its simplest, you pick the agent that matches the work at hand, but you can add more structure by including handoffs between agents.
• Skills are modular, reusable instructions that load only when a specific task triggers them. The skill description loads in every session so the model knows when to call it, but the full details only load when they're actually needed. For example, my UI Toolkit agent calls individual skills for styling, UXML writing, and related tasks depending on what's needed. This keeps the model's memory context efficient between tasks.

Tip 3: A great plan goes a long way

“Plan mode is the first step before any implementation starts. When you use the /plan command followed by your specific instructions, GitHub Copilot reasons through your codebase and requests to map out an implementation path before it writes a single line of code.

Be sure to describe the feature or fix in as much relevant detail as possible, then ask Copilot to investigate and return with questions. The exchange will help you think through the user experience and functionality in more detail, which often surfaces edge cases. Once that iteration is done, have the AI define the broad strokes of the implementation including what existing systems it uses, what new classes and methods you need to create, and how it all fits together. Only then should you let it write the code.”

Tip 4: Don’t skip the code review

“AI-generated code needs review, especially if it’s code that stays in the project long term. Once the implementation returns, you should treat it like a pull request and read through it.”

“I tried several different approaches to this before VS Code shipped the agent window, and I now use that the most. I can highlight specific code and use the /Explain command to have the AI walk me through what it does, or the /Review command to have it critique the code it just wrote. From there, I’ll add inline comments directly in the diff, as I would on a real pull request, and send them back as a group to the AI for iteration.”

“This habit matters because it keeps the code up to my standards and ensures I maintain a deep understanding of my systems. That knowledge helps me make the right design decisions as the game grows.”

Tip 5: Use AI as a personal tutor

“You can use GitHub Copilot to create a custom tutorial for any Unity concept you want to learn. Because GitHub Copilot can read your project, you can ask it to tailor the lesson to what your game needs and your skill level.”

"I’d wanted to learn shaders for a long time, so I built a Unity Shader Graph agent that leans hard into teaching and used it to make ground-targeting overlays for combat. When I encountered a concept I didn't fully understand, I could ask questions and only moved to the next step when I was ready."

"It’s important to use a series of lessons that build independence over time. For example, I asked it to provide guided tutorials for the first two shaders. It walked me through the unfamiliar nodes and the math so I actually understood how each shader worked. I wanted to build the third shader on my own, so when I got stuck I just asked for a hint instead of the answer. It gave me a couple of guiding questions that helped me identify the next step, and I kept going. By the end of the process, I actually understood what I’d created.”

In-depth look with Stacey and AI beta access

For a deeper dive, Stacey has shared several videos covering these topics on her YouTube channel. Access to Unity’s in-Editor AI assistant is available now in open beta. Start your free 14 day trial here.