Game programmers are a suspicious bunch when it comes to inputs, and historically, that paranoia has served us well. To ship games that actually hold together, we have to assume the player will try the impossible, the network will drop an important packet, and a few machines out in the wild will just behave differently. Now, there is one more untrusted input we need to worry about, and this one writes the code. AI coding agents have started doing production work inside our codebases. They write a change, compile it, parse the errors, and try again, iterating several times before a human ever looks at it. While the first draft arrives faster, the hardest part of our job gets pushed downstream into review. Reviews take longer, diffs get harder to trust, and the failures are very subtle. For example, logic may get duplicated, proposed fixes may hide symptoms rather than fixing the root cause, and changes may pass unit tests, only to trigger desyncs three weeks later. In this talk, we will treat agent-written code exactly like any other input we can't fully trust. Since we can't rely on the agent's reliability yet, we need to build a system around it strong enough to contain it. We will walk through common machine-authored failure patterns, how they manifest in our codebase, and how to build a practical harness to supervise them.
Target Audiences
Programmers, mid-level and up, using coding agents in production and rethinking their habits around them.
