Since May I have been working on a roguelike prototype, first in Three.js and now in Godot.

I started with Three.js because it was the fastest way to check the idea. After a small playtest with my friends, when I verified that it is fun at least for me in coop, I decided to move it to a real engine. I picked Godot, even though it is my first game with it.
And then I saw a long loading time.
Of course, the first temptation is to ask an LLM to "optimize the game" and hope for magic. But the better loop is still the old reliable one: profile first, then optimize if needed.
I checked the docs and found that Godot can be connected to Tracy. So I fed the docs to Codex and in one prompt it:

- downloaded Tracy
- set it up for the project
- made a capture
- analyzed the result
- proposed fixes

Then I asked it to apply the fixes, run a review with my functionality reviewer agent, and profile with Tracy again.
The biggest visible win was exiting the game to the lobby. Before it took around 3-5 seconds. Now it is basically immediate.

The complete result is in the pic

This is not a "LLM solved performance" story. More like: LLM made the profiling loop cheaper and faster.

Have you already used LLMs together with real profilers, not just for random code cleanup?

Give 🔥 if you want to hear what it was like for me to port the game from Three.js to Godot.

#performance #profiling #godot #tracy

12-Factor Agents for development workflows

It is mostly a guide, not a library you install and build your game on top of. There are some supporting packages and workshops in the repo, but the core value is the principles for building reliable agents.

The guide pushes against the "big prompt + tools + loop until done" approach.

I have been using AI coding workflows for multiple years already and that's the part where things usually break on big project. It might work for a demo or prototype. But in real Unity projects with long import times, slow build pipelines, and old god singletons no one wants to touch, suddenly LLM even with agents needs logs, state, approvals, retries, and boring deterministic scripts and tools instead of a magic AI button.

Few points I would steal for my game dev agents:

Own the prompts.
If an agent works on my project, I don't want the important prompt hidden inside a framework. I want it in the repo near requirements, diagrams, and maybe even next to scripts it can call. Same reason I like PlantUML: it can be reviewed, changed, reused.

Tools are just structured outputs.
"Run tests" should call a script. "Build WebGL" should call a script. "Check Addressables" should call a script. The LLM can choose what to try next, but it should not invent whether the build succeeded. Deterministic code should return the result.

Pause when action is risky.
An agent can prepare a PR, but I don't want it to push to master or upload a public build without explicit approval. Same for deleting assets, migrations, changing live configs, save compatibility, etc. It might sound obvious, but a lot of agent demos skip exactly this boring part.

Keep the state inspectable.
When an agent fails and retries, I want to see why. Unity has enough "works on my machine" mystery already. If the agent changed a prefab, fixed one error, then broke another platform, I need a history that can be inspected later.

Make agents small.
One agent for "prepare playable build" is okay. One for "investigate this crash report" is okay. A single agent that can modify code, assets, configs, CI, store metadata, and production data is a nice way to lose control. However I am wondering how many tokens can be wasted if there are too many small agents for each small step. Something I would like to test.

Of course, the repo is written mostly from SaaS/product experience, not Unity production. But I think the principles fit game dev really well, because our pipelines are slow, stateful, full of tools, and full of things that should not be changed by "vibes".

I am using my agent team at work daily and already modified it a few times based on the experience. Today I updated it according to 12-factor-agents principles, lets see if it yields better results or just turns into a bigger token drain with no significant benefits.

Have you already built any agent around your game project workflow? Not just coding in Cursor/Claude, but something that runs tests, checks logs, prepares builds, or validates assets, etc?

My unity agents:
https://github.com/AlexMerzlikin/unity-agent-team

12 factor agents:
https://github.com/humanlayer/12-factor-agents

#agent

I have been testing 5.6 Sol lately and haven't seen a really big difference to the old model when I used it with medium, high, extra high effort.

The only thing that surprised me was a co-op bot for my roguelike game. You press a bot run button on the host and it runs kinda optimal strategy and plays the game from all clients. It was done in around 2 prompts and works very well.
I was able to catch around 6 bugs already with it.

Then I added auto mode for LLM, it launches multiple clients each with their own set of launch args. And then LLM reads the console every 5 mins for each client to find anomalies or bugs. It also found a few bugs which led to an incorrect loss.

Apart from that other tasks were the same in terms of speed and quality as 5.5.

This morning I wanted to test 5.6 ultra and compare it against Fable 5, which I used at work to create a pretty big feature on which it worked for 2 days straight with pauses when it was hitting the 5 hour limit of $200 subscription.

So I selected ultra effort, started to write a prompt and then I saw the new update available. It must make things better, right?

I hit it, codex restarted, and the ultra mode is now gone 💀

Do you still have ultra effort on the latest codex version?

And have you tested it against Fable? Which one is better for you?

Drop 💯 if you want to hear more about my Fable experience and how it completed the feature in 2 days on its own.

Just now Open AI temporarily removed the 5h limit.

It's an interesting addition to the morning discussion we had here about hitting the 5h limit with sol ultra in 18-40 mins.

I hit the 5h limit twice today and have only 32% of a weekly limit left. Thanks Open AI, now I can spend my weekly limit in around 1.5 hours 💪💀

I transitioned my roguelike game from 2D to 3D to test Sol Ultra when it was released 1.5 weeks ago.

I def can say it was a successful experiment. The game was working, but lacked a few animations I had before.
I initially used original sprites as billboards in 3D world, but then eventually swapped it with very simple models. The game transformed from a simple 2d board to a stylized 3d after I threw in a few shaders and post effects.

And of course the game again became slower to load.
So I ran the same profiling with tracy and got the faster loading in just 5 mins.
Cannot recommend it more.

Meet the Unity CLI: manage Unity from your terminal

I had multiple posts about how I used godot because of great cli tools and now its time to test if Unity can match it. Seems like it doesn't have a lot of stuff yet, but it allows agents to eval any code without full recompilation and domain reload. So in theory agents can do any custom work with this command.

Has anyone tested it already?

https://unity.com/blog/meet-the-unity-cli

#cli

How Claude Code Uses Prompt Caching

I believe it's important to know what prompt caching is and how it helps save costs.

On this page, I would pay attention to what resets the cache, how agents affect it, how to check your cache usage, and TTL.

One advice I didn't follow before:

Compaction works in your favor when the context you discard is content you no longer need. To choose when its overhead happens, run /compact at a natural break in your work, such as between tasks, instead of waiting for auto-compaction to trigger mid-task. If you’ve gone down a path you want to abandon entirely, /rewind to an earlier turn instead. Rewinding truncates back to a prefix that is already cached, rather than building a new one as compaction does.

https://code.claude.com/docs/en/prompt-caching

#ai

Ponytail Skill for Claude Code: Does It Really Cut Tokens

An interesting read about measuring token savers. Shows how you can compare different tools if you have enough time 💀

https://blog.jetbrains.com/ai/2026/07/ponytail-skill-claude-tested/

#ai

How I made Unity handle half-a-million projectiles without dying : r/Unity3D

https://www.reddit.com/r/Unity3D/comments/1vn9aye/how_i_made_unity_handle_halfamillion_projectiles/

#optimization

Rendering at scale: Efficient strategies for massive object counts

Mega Cat Studios shared practical rendering lessons from Backyard Baseball: static batching, GPU instancing, vertex animation textures, culling, and the URP vs HDRP choice.

What I liked most is that the post starts where performance work should start: profile first, then optimize. They explicitly separate CPU- and GPU-bound problems, then explain the tradeoffs. VAT saves CPU time but adds memory pressure, batching saves draw overhead but can increase GPU memory.

This is not a magic checklist, of course. Still, real production notes from the tech trenches are much more useful than another “optimize your draw calls” summary.

https://unity.com/blog/rendering-at-scale-efficient-strategies-for-massive-object-counts

#performance #graphics #optimization

PerfLint puts AI optimization on measured ground

I have shared before the example how I used LLM and Tracy to profile a godot game.
And recently I experimented a lot with automating profiling our Unity game at work with the help of agents.

So I’m always skeptical when an AI agent “optimizes” a Unity project by reading files and guessing or even hallucinating (happened a few times in our team).
PerfLint takes a better route: deterministic rules measure assets, import settings, memory and build size, then expose findings through Unity CLI/MCP so an agent can explain or draft a fix.

The author reports Addressables duplication dropping from 337 assets to 5, and bundles shrinking from 1.29 GB to 805 MB. More interestingly, the tool caught an agent’s false texture diagnosis before it changed anything.

I haven’t tried it yet, take the numbers with a grain of salt, but “measure first, let AI explain” is the direction I want.

Have you tried it before or after this latest update?

https://discussions.unity.com/t/released-perflint-free-local-audit-for-build-size-performance-and-unity-6-migration/1734256

#performance #ai