I Sent Four Files to My Coding Model. Fifteen Minutes Later, I Had No Patch.

I bundled four files into one local-model request during a game update. The request reached its 900-second response limit without delivering a complete answer. I couldn’t apply a patch I hadn’t received.

This happened on November 4 while I was changing a boss’s movement and missile presentation. The feature crossed several files, so collecting them together felt reasonable. The resulting request wasn’t a useful unit of work.

I didn’t measure how much of those fifteen minutes went into input processing versus generation. My work log records slow processing and generation, followed by the timeout. It doesn’t establish a single cause.

The feature wasn’t one edit

The boss needed a three-second relocation phase after an attack finished. It also needed five launch covers to open in order, with missiles leaving their actual launch points. Existing attack timing and damage rules had to survive.

That’s one visible feature, but several contracts. Movement shouldn’t start another attack. A visual change shouldn’t move the collision logic. Cleanup still has to happen when the boss dies.

I use AI assistance to generate implementation code, then inspect and verify the result. Sending more source text doesn’t remove that responsibility. In this case it postponed the point where I could inspect anything.

Stage Recorded result What I could conclude
Four-file request Response limit at 900 seconds No complete response was available to apply
Smaller follow-up requests Functions and short replacements used Review could proceed on bounded changes
Review Missing list sizing, trail, and sorting details found Generated code still needed correction
Final verification Web and Windows builds exited successfully Build gates passed; gameplay needed its own checks

I haven’t preserved a controlled full-file-versus-fragment timing comparison here. I can’t claim the smaller requests were a measured percentage faster. The operational result is simpler: the large request didn’t deliver a complete patch, and the smaller workflow eventually produced a verified update.

What I changed about the handoff

I split the implementation by responsibility rather than by arbitrary character count. A movement edit needed the relevant state transitions. A launch visual needed the existing coordinates and cleanup contract. Each request could point to a specific replacement boundary.

I didn’t ask the model to invent the surrounding APIs. Existing names, types, and call order mattered. Without those, a short prompt could produce a short answer that didn’t fit anything.

The useful handoff wasn’t “fix the missiles.” It described the allowed change, the behavior that had to remain, and the evidence I’d use to accept it. I still had to read the returned code against the real source.

That review found omissions. Smaller output didn’t guarantee correctness; it made the omissions easier to locate. I’d rather inspect one missing cleanup call than guess which part of an unfinished four-file response was meant to be authoritative.

A build success didn’t close the job

The recovery had unrelated interruptions too. One verification run started with incomplete integration and was stopped. Another encountered Unity build-cache file errors. Those weren’t evidence that the original model request had corrupted the game.

I kept the failed attempts separate from the final result. The final record includes successful builds, rule checks, and browser execution checks. It also records relocation, launch-point alignment, and cleanup after death.

Desktop and mobile browser emulation were checked. Physical phones and native Windows gameplay weren’t covered by that record. I won’t turn “Windows build succeeded” into “I played the Windows version.” They’re different claims.

Don’t solve a missing response by applying fragments blindly

A timeout tells me I didn’t receive the expected completion in time. It doesn’t tell me which partial text is safe. I didn’t apply the incomplete four-file response.

For my workflow, the next step was a smaller, explicit request against the current source. I’d still check whether any earlier operation wrote a file before retrying a tool that can modify files. This particular record doesn’t establish duplicate writes or lost server-side work.

There’s also a limit to splitting. If two edits share a state transition, I can’t pretend they’re independent. I need to carry that dependency into both the instructions and the verification.

The lesson wasn’t that my local model needs a magical prompt length. I don’t have that number. I have one failed fifteen-minute request, a narrower recovery path, and a final result with inspectable checks.

I’ve written separately about what orchestrating local code generation actually cost. This case changed my unit of work: a request now needs a reviewable boundary, not just enough room for all the files.

Similar Posts