“It’s a blanket pulling on who gets more of the blanket, to not be cold.”
That’s how I finally described game-engine design to a friend, and I haven’t found a better model since. Every engine serves two audiences: the people who speak in code and the people who speak in editors. And every major engine treats their comfort as a zero-sum resource — one blanket, two sleepers, and someone wakes up frozen.
Heresy I was the personal arc — what the tug-of-war cost me. This one is the audit: four places where the blanket gets pulled, each with receipts, one measured directly off my own repository. And at the end, the reason I know it’s not a law of nature: another industry already solved it.
Exhibit one: GUI rules expire, language rules don’t
A programmer’s skill is speaking languages and APIs. An engine makes half your workflow knowing where things are in a GUI — which panel, which dropdown, what to drag where. Then the engine ships a UI reorganization, and that knowledge silently expires. Imagine if C# renamed its keywords every two years and the community called you lazy for grumbling.
To be clear about what I’m not saying: Blueprints, visual scripting, editor workflows — these are genuinely great for people who don’t write code. Unreal letting someone build a game with zero programming is an achievement. The heresy isn’t that the no-code path exists. It’s that the code path pays for it: dragging assets through explorer panels is the programmer’s workflow too, and there’s no professional lane where my craft knowledge — the kind that survives tool churn everywhere else in software — actually survives.
Exhibit two: the asset layer breaks git
Twenty years of version control, solved. Merge conflicts, blame, bisect, atomic commits — the single most load-bearing tool programmers own. Game engines quietly opt half the project out of it.
Here’s the measured version, from the archaeology of my own two-person game: a
19-day-old repository weighing 607MB, 280MB of which was .git — no LFS, no
.gitattributes, a 28MB texture in history, one audio file stored twice, and a deleted
13MB SDK entombed in the history forever by the commit that removed it. And that was the
repo without most of our assets, because they physically couldn’t ship to GitHub.
Our actual asset-synchronization protocol — two professional developers in 2024 — was: tell each other what we added, so the editors don’t commit seppuku. The industry’s answer to two decades of version control is a group chat.
Exhibit three: the generated-file storm
Unity persists editor state — what you dragged where, component wiring, import settings — into hundreds of auto-generated files. Two consequences. First, an editor tweak is invisible to your teammate until those files ship to the repo, so the source of truth is neither the code nor the conversation — it’s a diff nobody can read. Second, code review drowns: I spent months approving pull requests with a thousand changed files, where GitHub’s diff viewer would lag out before rendering. Why am I reviewing a billion changes the engine made to its own bookkeeping?
I tried to engineer my way out — gitignore the generated noise, rebuild the wiring dynamically at runtime. It never worked. I debated the problem with a friend who’d spent six years inside a game studio, and he had no answer either — not “here’s the trick,” but no answer, to a problem this basic. So I made a choice I want to state precisely, because it’s the blanket problem in one sentence: rewriting our workflow away from the editor would have cut off my teammate’s way of working entirely. So I gritted my teeth and kept approving thousand-file PRs instead. Somebody had to freeze. I chose me. 💀
Exhibit four: the blanket, live on camera
Unity’s UI story is the cleanest recorded footage of the blanket being pulled. The original UI system was awkward for both audiences. Then came UI Toolkit — USS and UXML, stylesheets and markup, genuinely web-shaped. I used it; I liked it; it was the engine finally speaking a language programmers already knew.
And in making it better for us, they broke it for the editor-people — the visual-first workflow that made the old system approachable to non-coders didn’t carry over, and adoption stalled into the gap. One blanket. Warm the programmers, freeze the designers. The engine didn’t architect a relation; it re-aimed the same scarce comfort.
(Honesty footnote: my UI Toolkit experience is from its early years, and I stopped tracking Unity closely after I left — this exhibit describes the era I lived, and a current-state audit runs before I’ll claim it’s still true in 2026.)
And everyone builds a node system anyway
The pattern completes itself: when designers need to express logic — quest chains, dialogue, NPC behavior — the engine’s answer is another GUI, and when the built-in one isn’t enough, your team’s programmer builds a custom node editor instead of the game. My teammate built one for quest logic between NPCs. Unity has since shipped its own; it’s bearable and slow. Somewhere right now, a two-person indie team’s strongest programmer is three weeks deep into meta-tooling their own dialogue graph, and the game is exactly as unfinished as before.
The peace treaty exists — I’ve seen it
Here’s why I refuse to call any of this inevitable. Web development had the identical war: designers and developers, one artifact, two languages of craft. And it signed a peace treaty — CSS as a shared border, component systems, design tokens, Figma-to-code pipelines. A designer changes a token and no developer’s workflow breaks; a developer refactors a component and the design system holds. Both sides of that blanket are warm, and nobody thinks that’s remarkable anymore.
That’s the standard I’m holding engines to — not “be nicer to programmers at designers’ expense,” which would just be pulling the blanket back. Architect the relation:
- Wiring as reviewable text — not editor state serialized into a thousand generated files, but a diff a human can read in a code review.
- Assets versioned like the first-class project members they are — not a side-channel held together by chat messages.
- The code path and the editor path as equal citizens — every editor action with a scriptable, documented equivalent, so neither craft’s knowledge expires when the other side’s tooling improves.
Two gives motion, three gives form. A team is engineers and designers in relation — and an engine’s actual job, the one nobody wrote in its marketing, is to be the architecture of that relation. The engines I left kept handing us one blanket and calling the shivering side lazy.
Heresy III is about what this does to people over decades — the dying masters, the secret engines, and why “made in Unity” became an insult players say to each other.
Covenant note: the repository weights, file counts, PR sizes, and commit archaeology in this essay are measured (July 2026) from the original repos. The UI Toolkit exhibit carries its own honesty footnote. The blanket metaphor is mine; you may steal it, that’s what it’s for. △○▽