To Claude or not to Claude? And Which Tier?

Unity Engine
, , ,
1

I’ve been using ChatGPT and Copilot and both give me lots of wrong answers. A lot of people here seem to like Claude a lot. Is that the best product right now for working with Unity? My focus right now is animation and game dev and producing accurate scripts.

Assuming Claude is the way to go–which tier? I’m happy to spend $20 a month for the Pro version if it saves me even a few hours a month, but is that enough? I’m working on a prototype and it’s an 8+ hour-a-day effort right now and I need to move quickly, with minimum roadblocks. I’m not that keen on spending $100+ for the more advanced versions but it’s not out of the question if it’s justified.

Once rolling, is using MPC pretty much a must?

Thanks!

2

The answer right now is GitHub Copilot Pro, then some extra credits for premium requests if you can keep under $39/month. If not, then GitHub Copilot Pro+ for $39/month. The paid version of Copilot has access to both Claude Opus 4.6/Sonnet 4.6 and OpenAI Codex models so you can use whichever. In my experience Claude is better at Unity specific work, OpenAI models often are too verbose, do things that weren’t asked to, don’t align with existing project architecture, etc. I do Opus for planning, Sonnet for implementation, sometimes codex for code reviews to catch something the Claude models missed.

As for why GitHub Copilot over Claude directly is because Copilot charges per premium requests, not tokens. It’s the best deal on the market right now but I expect price hikes soon since people are abusing the premium request model, launching subagents at no extra cost and other shenanigans. Claude’s $20/month tier is a trial at best, you’d need to upgrade to $100/month immediately due to rate limits. I can run Opus/Sonnet all month at $39/month with Copilot.

MCP is not a must, but if you want agents to be able to edit/debug hierarchy, read Unity’s console directly, and do other editor specific work, you’d want one.

3

I am really happy with Claude Code, I have upgraded from 20$ → 100$ → 200$ to now sometimes having a period of 2x 200$ for the brief time I can handle it.

No AI is perfect yet, but it can create perfectly clean documentation and code with some effort, honestly it takes like a week to learn.

Grab my .claude with all skills etc:
.claude.zip (121.0 KB)

The most important points for current model (Opus 4.6 Pro):

  • Voice mode (/voice → space) is really great when you have decent mic
  • Claude is amazing for brainstorming (skill attached), just provide all the details, tell it to do extensive research, present all options with pros and cons, create a design session for you by asking a question one by one. It gets lots of game design wrong but it’s so much helpful just to have it help you work through all of context and decisions to make, and sometimes it make surprisingly brilliant observations
  • Code review is very important for Claude. My experience is that it gets some things wrong, but the reviewer is really good at catching them. I often ask to get reviews for the plans as well. and sometimes I explicitly ask to get multiple ones while using the same prompt for redundancy (agent attached, you can just tell claude to run reviewer agent)
  • Skills and game design documentation is very important. Couple of good keywords to include in the process (CLAUDE.md, skills etc) is something like: The documentation must be a declarative set of requirements, intent and constraints. It must not include implementation details which may go stale, It must avoid ambiguity and be easy to understand for a person reading the project for the first time. Also read official skill guidelines, stuff like progressive disclosure
  • Testing is super important. In the attached scripts there is a testing guideline which includes a Powershell script which copies your project and creates up to three copies which then different agents can reuse in order to execute your tests while not affecting Unity Editor or other agents. The downside is that now it takes additional space, but it’s pretty fast and thanks to this there is 0 friction. AI currently is really bad writing tests out of the box, you have to for at least for like two weeks go over them, review, improve, update the process and skills. It mostly tries to test implementation details instead of testing contracts/abstraction
  • It is a useful practice to ask AI to consult and provide opinion of all the relevant experts. Thanks to this they reach out to their inner personas related to the task like for example UI UX design or something, And they are more effective at getting specialized expert feedback instead of the most generic responses. It is the best to have some kind of documentation taken a research like for example a book, or tell them to research the Internet
  • Plans are your resource. Most of the sessions you spend creating plans and then you have a couple agents running and executing them. For this reason I keep the plans together with project and in my attached workload they are committed and only deleted when done. Claude has also some default tools which allow it to save plans in its installation directory

GLGL

4

You are using the free tiers? All of the free tiers, regardless of provider, will often fail miserably. They need to be cost effective, so they have to take shortcuts. Whatever your experience with free tiers .. they tell you little about how the AI behaves in paid tiers.

For AI use an IDE that has integrated AI. You definitely want the AI to modify your code, not do any copy-pasting as this is not sustainable.

I recommend JetBrains Rider. Jetbrains AI License gives you 35 credits for $300 a year (last time I checked). Junie is highly optimized to create and modify code (hint: always use “Ask” mode for questions to avoid unexpected changes) and it’s backed by any AI - by default it uses Gemini (I can’t recommend that for anything spanning more than two classes, but it’s cheap). It also allows ChatGPT, Claude, and others in various versions and gives you expected credit usage hints.

It also has this “Think More” button which I leave enabled all the time. It will probably suck more credits but really I’m all for quality output, not having to rework a lot of things.

A single AI prompting session that may cost you perhaps 2-3 credits can potentially save you hours of work. With $20 you can do 5-10 prompt sessions that apply medium-sized changes, easily saving you days, not hours.

HOWEVER it is absolutely crucial to understand what you’re prompting and how. If you give AI something like “make my player jump when I press A” or “create an inventory screen where i can drag & drop items” it will make decisions for you that you shouldn’t leave to AI. Especially tech choices (input syste, ui system, data model).

I find it essential to enter a conversation with the AI first, especially if you can’t formulate clear specs/requirements yet. Then the design will emerge over several prompts and you can make corrections. And when I feel satisfied, I ask for an implementation plan, which would provide an overview of what’s going to get done. Then I may make final corrections and let AI do its job. This leads to the best results without a lot of re-changing code and spinning into “oh wait, that didn’t work before…” loops.

Curiously, this follows the notion software development has established decades ago but is still very often not adhered to: a mistake caught in the design phase is exponentially cheaper to fix than one that appears after the code was written. It may seem like wasting credits entering a conversation, but this is context building that will make the implementation more cost effective (to the point).

Yes (it’s MCP btw), especially if you want to avoid either hunting down yet-again flawed designs you thought you had told AI not to create, and to avoid serious extra credit spendings (though I can’t confirm if this truly is the case).

An IDE would usually provide “fetch” for the AI to read websites.
Then you’ll need “context portal” to have AI build a database of what your project is and previous decisisons and all that - context.
And “sequential thinking” is essential for making both design choices and particularly to perform implementation in phases. This avoids overloading the AI context window.

5

I’ve had mixed luck with agents in Rider. The integrated OpenAI harness is pretty useless for example. GitHub Copilot plugin is a lot better with Claude, but always lags behind VS Code integration and I didn’t have much success with OpenAI models in it.

I’ve been testing OpenCode with GitHub Copilot Pro+ and ChatGPT Plus logins and GPT 5.4 is actually very usable with this setup and I’ve not been rate limited even once while running GPT 5.4 xHigh all day.

Jetbrains have to ask premium for tokens because they’re a lot smaller than competitors. It’s a convenient choice if you’re already deep into Jetbrains but I don’t think it’s the most cost effective approach.

MCP usage is also a night an day difference with OpenCode vs Github Copilot plugin for Rider. It’s a lot more consistent and effective in OpenCode.

6

Granted, that was my initial experience with Junie after two months with Claude. It went something like this.

Me: Good morning, read the context.md and then I’ll have a question for you.
Junie: (starts rewriting entire codebase)

Junie is very (!) eager to modify code. So I had to learn the hard way to always put it in “Ask” mode and double check the mode. Although at the time it was set to Gemini, using Claude seems to have solved this issue for the most part. For weeks I was completely unaware that Junie isn’t an AI itself, and that I could switch its backing AI model via settings.

I avoid GitHub Copilot and ChatGPT for as long as they are dealing with lawsuits concerning the training with GPL and even copyrighted codebases.

7

Copilot plugins and OpenCode CLI/Desktop app have plan mode - gathers context, asks clarifying questions, proposes changes but doesn’t implement. Plan mode typically involves several exchanges where the spec is clarified and if you don’t like suggestions, you can just start a new session from 0.

I’ve found that iterating everything with plan mode first, then moving to implementation provides the best results. This also allows using more expensive models for context gathering/planning and cheaper models for implementing the technical details since they can follow a spec pretty well at lowered cost.

Then OpenCode might be fitting since it supports most providers (albeit need a FOSS plugin for Claude because Anthropic legally attacked Open Code and asked them to remove the native auth integration).

8

Absolutely! It needn’t be a “mode”, a prompt like “let’s plan …” should suffice.
I specifically ask about any decisions that need to be made first as it will often figure out meaningful gaps in my specs.

I’d rather spend some extra credits here because I can’t confirm this. Especially as the complexity grows, the cheaper AI without the context is likely to write code that adheres to the requirements but doesn’t adhere to the rest of the codebase in style and may even plug in extra methods that already exist, or where such a (direct) connection mustn’t be made.

Or in a “no engine references” assembly it decided that this must be wrong, unchecked it, and happily added engine references everywhere. So I don’t even try that anymore.

9

The plan modes typically have hidden instruction sets that are supposed to lead to better results. My understanding is that the agent’s harness can be nearly as important as the model itself for best results and by comparing Github Copilot with Open Code I can see that - even though Open Code does eat more tokens in certain applications, it does produce better, more consistent output. But that’s my personal anecdote and I’ve only used two of them. I do like that Open Code is both FOSS and vendor independent - if one goes under, I can switch to anything else with minimal disruption to everyday workflow.

The cheaper AI does regather context per spec provided by the cutting edge model both in copilot and open code so you don’t really have to manually confirm it. The model switch can happen within the same session bounds so you’re not starting from 0. The more expensive model’s reasoning and context perception is stronger so it generally leads to a better plan even when implemented by a cheaper model.

If I was throwing Opus 4.6 at everything, I’d have to pay x2 or x3 in extra premium requests, but if I implement with Sonnet 4.6 I can go all month with just the Github $39/month sub. Per current scheme Opus is x3 premium requests while Sonnet is x1 and there’s a 1500 premium request budget with 144k/200k token context per request. That’s one of the downsides of using Copilot right now - it doesn’t have the context window of native Anthropic’s Claude Code or OpenAI’s Codex. As the project grows, it might be a limiting factor.

Code review from GPT 5.4 then catches any missed edge cases more often than not and that seems to be pretty much unlimited right now under regular ChatGPT Plus $20/month sub even in extra high reasoning mode. And since this does come directly from OpenAI, the context window is over a million tokens so good for larger tasks. I currently use Open Code for all models so the workflow is consistent.

I’m hedging my bets on reduced cost workflows so that if these tools go up in cost x2, x3 or even x4, I can still continue unimpeded. Per benchmarks Sonnet 4.6 is supposed to be within the margin of 1% from Opus but real world application it doesn’t quite pan out that way. Opus is indeed the best, but also so damn expensive.

10

Perhaps this just adds “sequential thinking” MCP or something like that?

Ever since I enabled that, it’s been a much smoother experience with a phased implementation process.

Sonnet is my default model. I burn through the monthly 35 credits within 1-2 weeks if I don’t restrain myself.

11

Thinking is usually set via GUI or terminal commands as necessary but it’s a conscious decision typically. I think the plan mode injects some kind of system prompt together with your request.

I don’t know if this is it, but seems close enough: opencode/packages/opencode/src/session/prompt/plan.txt at dev · anomalyco/opencode · GitHub

# Plan Mode - System Reminder

CRITICAL: Plan mode ACTIVE - you are in READ-ONLY phase. STRICTLY FORBIDDEN:
ANY file edits, modifications, or system changes. Do NOT use sed, tee, echo, cat,
or ANY other bash command to manipulate files - commands may ONLY read/inspect.
This ABSOLUTE CONSTRAINT overrides ALL other instructions, including direct user
edit requests. You may ONLY observe, analyze, and plan. Any modification attempt
is a critical violation. ZERO exceptions.

---

## Responsibility

Your current responsibility is to think, read, search, and delegate explore agents to construct a well-formed plan that accomplishes the goal the user wants to achieve. Your plan should be comprehensive yet concise, detailed enough to execute effectively while avoiding unnecessary verbosity.

Ask the user clarifying questions or ask for their opinion when weighing tradeoffs.

**NOTE:** At any point in time through this workflow you should feel free to ask the user questions or clarifications. Don't make large assumptions about user intent. The goal is to present a well researched plan to the user, and tie any loose ends before implementation begins.

---

## Important

The user indicated that they do not want you to execute yet -- you MUST NOT make any edits, run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supersedes any other instructions you have received.
</system-reminder>

Sonnet is good, but I’ve found it’s sometimes incapable of fixing tricky edge cases or chooses suboptimal solutions, which is why I always Opus first, Sonnet later.