BuildNot yet confirmed elsewhere1 publisher3 min readPublished
Unity's AI problem is not the prompt: the load-bearing context lives in the prefabs
A shipping-games veteran argues assistants fail on mature Unity projects because versions, scene ownership and serialized references sit outside the code. Score accepted changes, not lines.
The Engineer · Build desk
What happened
- A dev.to piece on context engineering for Unity argues that assistants stumble on long-running projects because of the context around the prompt, not the prompt.
- Its failure list is code that compiles but assumes the wrong input system, edits a prefab meant as a template, calls an API absent from the installed package, or adds a rival architecture.
- Unity versions, package versions, scene ownership and serialization rules are listed as things that must never be left to guesswork.
- The scoring rule offered is accepted changes and review cost rather than generated lines of code.
Why it matters
- constraint If a method rename can break a serialized reference the compiler never inspects, refactor-shaped tasks stop being safe to delegate at all until someone has written down what points at what.
- decision Any team currently reporting assistant value in lines or suggestions accepted by the editor has to choose: switch to accepted changes and review hours, or keep defending a number that hides the...
- cost Without tests the reviewer is the test, and the reviewer who can adjudicate scene ownership is the most expensive person on the team, so unchecked output moves spend from writing to reading.
- exposure Asset publishers carry someone else's blast radius: a silently added dependency or a touched project setting lands in customer repositories, where the vendor cannot review the damage.
The reason Unity punishes assistants harder than a plain service codebase does is where the behaviour is kept. The article enumerates nine places outside the C# that can carry load: scenes, prefabs, ScriptableObjects, animation controllers, physics layers, tags, package manifests, quality settings and platform-specific configuration [5][16]. Against that, its worked example is a model handed three source files [6]. The rename it proposes compiles. It is unaware that a serialized event in a prefab depends on the method being renamed [6], and the compiler will not raise it.
The brief the author proposes is not documentation in the usual sense. It records the decisions that must not be reinvented: editor version, render pipeline, supported platforms, input solution, major packages, assembly layout, testing approach, and the directory boundaries between runtime code, editor code, samples and third-party dependencies [11]. A second layer names in plain language which system owns game state, how scenes transition, how services are located, which ScriptableObjects are configuration and which hold runtime state, and whether asynchronous work runs on coroutines, tasks or a project abstraction [12]. He is explicit that this is a contract stating which choices already exist, not an invitation for the assistant to redesign them [12]. There is also a prohibited list. An asset package must not silently add a dependency, modify global project settings, or require customers to restructure their scenes [13].
The sequencing is the useful part. When a task looks doubtful, the author improves the evidence before he improves the prompt: file paths, Unity and package versions, architectural boundaries, expected behaviour, known risks [9][10]. Tasks stay small enough to carry explicit acceptance checks [18], and automated tests are what turn a plausible suggestion into evidence [19].
What the piece does not carry is a measurement. There is no accept rate before and after, no review hours counted [14]. It is a practitioner argument built on sixteen years of game development [7], with Eagle Flight Arcade at Ubisoft Montreal in 2016 offered as the illustration: one title, three headsets, meaning a change that reads as local interacts with input, performance, comfort and build configuration [8][15].
Read against the brief's own framing, the interesting implication is that none of this apparatus is AI-specific. The author says the brief should explain the repository the way he would explain it to a developer joining for a focused task [11]. Version pins, scene ownership, serialization rules and a written boundary between runtime and editor code are what you hand a contractor with two days. A team that cannot produce that document has a repository problem, and the assistant is only the first reader honest enough to fail loudly on it.
What to watch
- A team publishing accept rates and review hours before and after adopting a project brief would turn this from practice into evidence.
- Whether Unity ships version pins, scene ownership and serialization rules in a machine-readable form an assistant can consume without a hand-written brief.
- Whether asset store review starts asking publishers for a written prohibited-change list of the kind the author keeps.
Clarity's read
What the record supports and how the coverage leans. The claims behind it follow.
Reality
- Evidence28
- Adoption10
- Hype gap+14
- Incentives45
- Confidence34
Claim ledger
Ranked by verification strength, evidence, and original report placement.
- [1]
The author states that production work depends on assumptions scattered across scenes, prefabs, packages, build settings, naming conventions and platform requirements, and that an AI assistant cannot respect information it cannot see.
- [2]
Stated takeaway: measure accepted changes and review cost, not generated lines of code.
- [3]
Stated takeaway: Unity versions, package versions, scene ownership and serialization rules must never be left to guesswork.
- [4]
The author reports the common failure mode is not syntax: generated C# compiles, but it assumes the wrong input system, modifies a prefab that should be treated as a template, calls an API unavailable in the installed package version, or creates a second architecture beside the one already in production.
- [5]
The article states important Unity behaviour can live in scenes, prefabs, ScriptableObjects, animation controllers, physics layers, tags, package manifests, quality settings and platform-specific configuration.
- [6]
The article states a model shown three C# files may produce a reasonable answer for those files while remaining completely unaware that a serialized event in a prefab depends on the method it wants to rename.
- [7]
The author states sixteen years of experience in game development.
- [8]
The author shipped Eagle Flight Arcade as a Gameplay Programmer at Ubisoft Montreal in 2016, targeting PSVR, Oculus Rift and HTC Vive, and cites the platform matrix to show that an apparently local change can interact with input, performance, comfort, hardware behaviour and build configuration.
- [9]
The author's first question on an AI task is whether the model has enough evidence to understand the job rather than whether it can write the code; if not, he improves the evidence before refining the prompt.
- [10]
The author supplies relevant file paths, Unity and package versions, architectural boundaries, expected behaviour and known risks with a task.
- [11]
The recommended project brief explains the repository the way the author would explain it to a developer joining for a focused task, and begins with Unity editor version, render pipeline, supported platforms, input solution, major packages, assembly layout, testing approach and the directory boundaries between runtime code, editor code, samples and third-party dependencies.
- [12]
The brief's second layer describes architecture in plain language: which system owns game state, how scenes transition, how services are located (dependency injection, explicit references, static access or another pattern), which ScriptableObjects are configuration versus runtime state, and whether asynchronous operations use coroutines, tasks or a project-specific abstraction. The author states this is a contract telling the assistant which choices already exist, not an invitation to redesign them.
- [13]
The author documents prohibited changes: an asset package should not silently add a new dependency, modify global project settings, or require customers to restructure their scenes.
- [14]
The article's guidance is stated as practitioner experience; it supplies no measured accept-rate or review-cost figures for projects before and after adopting the brief.
- [15]
Eagle Flight Arcade's named platform matrix comprises three headsets.
- [16]
The article names nine locations outside C# source where Unity behaviour can be stored.
- [17]
The article argues AI coding tools are impressive in a clean demo and much less impressive inside a Unity project that has been shipping for years, and that the difference is usually the context surrounding the prompt rather than the prompt itself.
ReportedInsufficientSource: dev.to, Context Engineering for Unity2 sources— create a free account to open themView cited source - [18]
Stated takeaway: small tasks with explicit acceptance checks outperform broad feature requests.
- [19]
Stated takeaway: automated tests convert plausible AI suggestions into evidence.
Sources
1 independent publisher whose own reporting we read for this story.
- dev.toContext Engineering for Unity: How to Make AI Useful on Real Projects
1 article · August 24, 2026
Topics and entities
Follow any of these and your For You feed starts watching them — no settings page required.
Topics
- AI Coding AssistantsFollow
- Unity Game DevelopmentFollow
- Engineering Productivity MetricsFollow
- Code Review and Test GatesFollow
- Context EngineeringFollow