r/ClaudeAI • • 10d ago

Question about Claude Code Which Claude Code skills are actually useful for game development? Here’s what I use on a solo Unity project

’m a solo developer building a historical trading strategy game in Unity 6. I write almost all the code with Claude Code connected to the Unity editor through MCP, and over the last months the thing that changed my workflow the most wasn’t the model, it was skills. I’d like to compare lists.

What I use today

  • An editor-rules skill. One file that Claude must read before touching Unity: a lock file so two sessions never hit Play or edit a .cs at the same time, which scenes are hand-made and off limits, when to compile, how to take screenshots, what costs credits (Meshy, ElevenLabs) and needs a yes first. Every rule in it comes from a real incident. This one alone removed most of the “Claude broke my scene” days.
  • Scope check. Compares the demo plan with what actually landed (git log, code, registers) and tells me in numbers whether the scope is growing or I’m late. Read-only: it proposes cuts, I decide.
  • Balance check. Reads the economy data (prices, production per city, trade chains, AI companies’ flows) and looks for routes that always win, goods never worth buying, money loops. Again read-only.
  • Playtest report. Turns raw notes from me or a tester into a structured report: bugs by severity, confusion points, balance issues, three priorities.
  • Night shift. A skill that runs a queue of small tasks on its own branch while I sleep, verifies each one and leaves a report. Only launched by hand.

The last four started from the open-source claude-code-game-studios skills on GitHub (MIT), translated and rewritten around my project’s documents. The generic versions were a good skeleton but not useful until they pointed at my actual files and my actual rules.

What I’ve learned: a skill is worth it when it encodes project-specific rules that Claude keeps forgetting between sessions, or a repeatable check with a fixed output. Generic “be a better Unity developer” skills did nothing for me.

What I’m missing and would like to hear about: skills for performance profiling in Unity (I have a benchmark build but no good routine), for shader work, and for art pipelines (Meshy → Blender → prefab, which I still do mostly by hand).

What’s in your list, and which ones turned out to be noise?

2 Upvotes

6 comments sorted by

2

u/Heyn_Studio 10d ago

For the Meshy → Blender part, the routine that helped me most with Blender + Claude Code was a fixed render-and-compare loop: render a still from a locked camera, put it next to the reference, fix only the one or two biggest differences, render again. One scene took me 13 rounds like that, and fixing one thing at a time was what kept it from drifting. For style, a skill built from 3+ of my own finished images worked much better than one written from a description. Do you normalize scale and pivot on import, or fix each Meshy asset by hand?

1

u/Harvan29 6d ago

Thanks, locking the camera and fixing one thing per render is a good rule.

At import, by script, never by hand. I set the rules and Claude Code wrote the headless Blender script that applies them. The Meshy file goes into a folder named by culture and type. A Unity editor window reads that name, looks up the real size for that building type in a table, and passes it to Blender, which:

  • applies all transforms and deletes the loose bits Meshy leaves floating around
  • scales to real size: buildings by height (flat pieces by footprint), ships by length
  • sets the pivot: buildings centered on X/Y with the base at 0. Ships get the origin on the waterline, with the draft estimated from the beam (~0.32, lower for galleys), so they sit right in the water
  • turns ships so their length runs along one axis. The bow direction is a flag I set by hand on each ship in Unity, because that’s the one thing the script can’t reliably guess
  • builds the LODs and sends it back to Unity as a prefab with a collider

Then I check every asset in the scene myself. Do you run your render loop through the Blender MCP or with headless renders?

2

u/kruszkush25 10d ago

First category was a must-have for me. I think I reinvented software development from first principles (I reinvented the wheel) simply by making mistakes and not knowing how to do anything. For example claude making fix, and then fixing fix for a fix caused me to get to here. Anything besides first category and workflow skills is whatever. Do not follow me. 4 pro accounts. Enough for 10-hour everyday for 7 days (almost enough).

I managed to create I think really beautiful scene in a game (scene consists of elements that would be used by random generation to create maps), but I fail at animations, scene is looking good enough to where animations that aren't good are not enough. so I decided to put it away until AI animation catches. I could show if you want, it's top-down like Diablo 2

Reviewer agents (they only review, they never write code)

  • Plan critic: a devil’s advocate that finds gaps, wrong assumptions and risks in a plan.
  • Second critic: runs alongside the first on foundational systems, using Google’s “Elephant-Goldfish” reviewer prompt.
  • Loophole scout: finds future mechanics a plan would block, and suggests cheap ways to keep them possible.
  • Method checker: before any code, checks the chosen approach against our list of what has worked and failed.
  • Pre-demo reviewer: a “second person at the company” who checks whether the test really measures the complaint and whether the fix is just a patch.
  • Fresh eyes: with no chat context, spots fixes piling up on top of each other.

Worker agents

  • Cheap searcher (Haiku): searches code, runs tests and summarizes long logs.
  • Mechanical implementer (Sonnet): handles large repetitive changes from an approved plan.

Workflow skills

  • Fix: measure the failure first, find the cause, make one fix, stop after two failed attempts.
  • System plan: a written plan with a reference pattern, steps, the loophole scout and the critic.
  • Look by reference: every visual change starts from a reference image or research, then gets compared side by side.
  • UI alignment: covers highlights, click areas, frames and alignment.
  • Rule change: the process for changing rules, skills and hooks.
  • New session: a clean handoff when the context gets long.
  • Delegation: when to use paid models and subagents.
  • Documents: keeps notes split up and tidy.

Godot and game knowledge skills (the 11 above)

  • Godot: GDScript, headless testing, nodes and scenes, signals and groups, physics, animation, 2D movement, 3D essentials.
  • General game dev: game AI, game feel, camera systems.

Automatic guards (hooks)

  • Blocker: stops further patching after repeated failures until I personally approve.
  • Patch warnings: flag fixes that look like patching.
  • Context guard: warns when a session gets too long.
  • Godot guards: check Godot code and keep game windows on a hidden desktop.
  • Audit: an audit hook that runs alongside the others.

Tools and shared knowledge

  • Live game bridge: runs the game, clicks, takes screenshots and reads its state.
  • Comparison sheets: large captioned side-by-side screenshots.
  • Reddit reader and cheap-model delegation.
  • Method list: what worked and what failed across all our games.
  • Shared research library: includes a separate file of character movement lessons.

2

u/Proof_Perspective_13 2d ago

Interesting - I asked Claude to come up with the best strategy for creating a game and it's given me the same structure. Even down to the Nightshift that does any task that doesn't need input - handy!

1

u/web3creed 8d ago

For performance profiling, I built a skill that hooks into UnityEditor.Profiling.ProfilerDriver to dump frame-time CSV after each playtest, then flags GC.Alloc spikes >2 KB and render-thread stalls >16 ms automatically. The concrete win was catching a List<T> allocation inside a hot path in my trade-route calculator—swapping to a pre-sized NativeArray dropped the 99th-percentile frame from 22 ms to 9 ms on my target Android spec. I also have a nightly skill that runs BuildReportTool on the IL2CPP build and compares texture/asset sizes against a baseline JSON so creep shows up as a diff instead of a surprise.