AI in Game Development: The Big Walk Controversy
The Big Walk dispute shows why tiny AI-assisted code changes raise major questions about disclosure, awards rules and indie game development.

Big Walk's AI Bug Fix Exposes a Hard Problem for Indie Games
A game can include only a small amount of AI-assisted coding and still end up at the center of a serious argument in the industry. That's what happened after House House said it used a large language model (LLM) to help solve technical problems during development of Big Walk. The studio said the use was limited - well under 0.1% of the game's code. But some jurors at the Independent Games Festival (IGF) said that amount didn't matter. They said they wouldn't vote for games that use generative AI in any form.
This isn't just a fight about one bug. It highlights a real mismatch: developers may treat AI as a narrow engineering tool, while players, jurors, and other stakeholders may see it as a labor issue, an environmental concern, a question of attribution, and even a trust problem. This piece pulls apart what's known about the Big Walk situation, what's still disputed, and how studios and awards groups can handle AI use without pretending every case is the same.
What happened with Big Walk and the IGF jury
The dispute started around the Independent Games Festival Awards, a well-known awards program for indie games. According to Ars Technica, 19 jury members - out of a group of more than 50 - signed a statement saying they would decline to vote for any game that uses generative AI in any capacity. The jurors cited concerns about the environment, the economy, workers, and psychological well-being. They also urged the IGF to adopt a strong policy that would bar games containing AI-generated work in future years.
The statement didn't single out any title. But Big Walk became the center of the discussion after House House told Aftermath - and later added to the game's FAQ - that it used LLMs sparingly near the end of development to deal with technical challenges and bugs.
The studio's account of the bug fix
House House said one problem involved Unity engine shadows that could show up with "infinite length" in certain situations, which slowed the game down. The studio said it consulted a Unity engineer, who concluded a fix wasn't possible, and then asked an LLM for ideas. The chatbot suggested an approach; House House said it then had to modify that approach extensively. The studio's claim is that the final game included only 10 lines of code that came from that process.
Even so, the studio's story doesn't end the debate. The estimate - AI-assisted work was "well under 0.1% of the game's code" - helps describe scale, but it doesn't settle whether that use would be acceptable under a particular set of principles. It also doesn't answer what players should have been told, and when.
What is known - and what remains contested
From reporting and the studio's own disclosures, it's fair to say: House House used an LLM during debugging and later talked about it publicly. It's also clear that some IGF jurors said they wouldn't vote for games that use generative AI. Those positions collided publicly, even though the jurors' statement never named Big Walk directly.
The technical details are harder to pin down. Ars Technica reported that at least one social media user argued the bug could have been fixed with enough human effort. That isn't the same thing as an independent technical review, and it doesn't prove the developers are wrong. The useful way to separate the questions is this: did AI contribute to the shipped work, and was AI necessary to solve the problem? The first question is mostly about disclosure. The second is a technical call that needs evidence.
Why a small amount of AI use can cause a big dispute
It's tempting to treat percentages as clarity. If someone says "well under 0.1% of the code," it sounds measurable. But that figure doesn't tell a player or juror what the tool actually did - did it generate something that shipped, suggest a direction, help interpret an error, or produce material that was then heavily reviewed? It also doesn't show whether the same kind of AI help was used elsewhere in the build process.
So two people can read the same disclosure and still walk away with opposite conclusions. A developer might see the chatbot as one debugging aid among many: it offered a possible route, and the team did the engineering work to make it real. A critic might see any generative AI involvement in shipped code as crossing a boundary on principle. Counting lines alone doesn't settle either view.
The word "AI" covers different activities
A studio's policy gets messy when it lumps all AI uses into one bucket. In practice, the meaningful distinctions often look like this:
- Exploration: Helping explain an error or listing possible causes, with nothing generated actually entering the game.
- Development assistance: Suggesting or drafting code that developers then review, edit, and test.
- Shipped content: Generating or materially shaping code, art, writing, audio, or other work that appears in the released game.
- Production operations: Supporting tasks like documentation, testing, or internal workflows that don't directly create player-facing content.
These categories aren't meant as moral rankings. They're useful because they match different factual questions. Brainstorming a debugging path is different from generating dialogue or rewriting code that ships unchanged. A policy can still ban both - but if it does, it should say so directly, not hide behind an ambiguous label.
Process and impact are separate questions
The jurors' concerns go beyond whether AI output is visible in the finished game. They pointed to labor, the environment, the economy, and mental well-being. A developer can view a use as technically small and still face objections about what's behind the tool and how it's used.
At the same time, the Big Walk case shows why blanket statements can create practical confusion. When jurors say "any capacity," does that include asking a chatbot to explain an engine error if no generated code ever gets used? Does it apply only to generative systems, or also to other machine-learning tools? The jurors' position is clear for voting purposes, but awards programs still need definitions if they want consistent eligibility decisions.
The real issue isn't just whether AI was used. It's whether everyone involved agrees on the boundary - and whether the developer gives enough information for others to judge that use against the boundary.
How indie studios can set a workable AI policy
Small studios don't need a huge compliance team. What they need is a rule that won't collapse under deadline pressure. If a policy is written only after an AI-assisted fix ships, the team is left reconstructing what happened from memory - while audiences may reasonably ask why disclosure came late.
A workable policy starts with two decisions: what AI uses the studio allows internally, and what uses must be disclosed externally. Those choices are related, but not identical. One studio might allow AI-assisted debugging but require disclosure when generated code ends up in the final product. Another studio might ban generative AI entirely. Either way, the key is making the call before a hard production problem forces it.
Use a simple decision flow
For each use, write down the answers to these questions:
- What task was the tool used for? Be specific: debugging, drafting, art generation, writing, testing, or something else.
- Did generated material enter the shipped game? Separate exploratory advice from code or assets that actually made it into the release.
- How much human review and modification happened? Keep a short note about what the team accepted, rejected, or changed.
- Are there data or rights issues to consider? For example, did the team submit confidential material, and can it explain where any output came from?
- Who needs to know? Decide whether the details belong in an internal record, a player-facing disclosure, a store page, a submission form, or multiple places.
This isn't a claim that documentation solves every ethical concern. It does, however, help the studio produce an accurate account of its own choices - which matters when a publisher, award organizer, or player asks later.
Match disclosure to the use
Disclosure should be specific enough to be useful without turning into a blow-by-blow list of every tool used during production. For example, a studio might say: "AI tools were used for internal brainstorming, and no generated material entered the game," or: "An LLM suggested an approach to a bug; developers substantially revised and tested code derived from that suggestion." Those descriptions match very different workflows.
If a studio decides a particular AI use isn't something it needs to disclose, it should still document why internally. That keeps later decisions consistent when similar cases show up. And if an award submission asks about AI, answer based on the organizer's definitions - not on a narrower interpretation you think the organizer might prefer.
The trade-off is real: too much disclosure can invite scrutiny, but vague disclosure can damage trust if more details come out later. In most situations, a brief, factual description is safer than silence or a broad claim that hides what actually happened.
What awards programs should decide before submissions open
An awards jury can take a clear stance on generative AI. It can also decide that any use is disqualifying, or that jurors may abstain on particular votes. The problem is timing: if those rules get created - or clarified - after submissions arrive, developers will be judged by standards they couldn't reasonably anticipate.
The IGF jurors' statement matters because it made a clear voting preference public. Still, it isn't the same thing as an official policy adopted by the festival itself. That distinction matters. Jurors vote; organizations set eligibility rules. An organization has to define what counts, gather consistent information, and explain how the rule applies in edge cases.
Define the boundary in operational terms
A policy that people can actually follow should spell out at least four things:
- Scope: Is it generative AI only, or does it include other machine-learning systems? Does it cover code, art, writing, audio, and production tools?
- Threshold: Does any use automatically disqualify a game, or only AI-generated work that ends up in the submitted title? What about assistance that stays internal?
- Disclosure: What entrants must report, and how detailed the report needs to be.
- Review and consequences: Who evaluates disclosures, how decisions can be challenged, and what happens if submitted information turns out to be incomplete.
Without definitions like these, two teams can use tools in similar ways and still get different outcomes simply because one described its workflow more carefully. That's an administration problem as much as a communications problem.
Separate eligibility from judging preference
There are two common approaches to objections. One is an eligibility rule: games that meet a defined condition can't be considered. The other is an individual voting principle: jurors can decline to support a game based on their own views about its production.
The eligibility approach creates a shared standard, but it requires consistent administration. The voting approach preserves individual judgment, but it can make outcomes harder for entrants to predict.
An awards program should say which approach it's using and explain the difference. If it adopts a ban, it should apply it consistently and make the submission questions easy to answer. If it leaves decisions to jurors, it shouldn't imply that a disclosed use has been formally prohibited when it hasn't.
No wording will satisfy everyone. The practical goal is smaller: reduce surprises, make comparable cases comparable, and give entrants enough information to plan their work and their submissions in the first place.
Key takeaways
- Even a tiny share of AI involvement in a game can trigger a big dispute, because people disagree about the principle - not just the quantity.
- The Big Walk account describes LLM-assisted debugging, but it doesn't settle whether the bug could have been fixed another way.
- Studios should separate exploration, development assistance, and material incorporated into the final release.
- Keeping a short internal record makes later disclosure more accurate and reduces avoidable confusion.
- Awards programs should publish their scope, thresholds, and consequences before submissions open.
Conclusion: Make the rule clear before the next controversy
The Big Walk dispute isn't a clean referendum on whether AI belongs in game development. It's a clash between a developer's account of a narrowly scoped engineering aid and jurors' stated refusal to support games that use generative AI at all. The amount of code matters for context, but it can't resolve the deeper disagreement about labor, provenance, and what counts as acceptable use.
For studios, the practical move is to define what they consider permitted uses, keep a lightweight internal record, and disclose material contributions accurately. For awards programs, the practical move is to publish clear rules before developers submit their work. Neither step removes disagreement. But both make it possible to argue about the actual decision - rather than discovering the rules only after the work is already done.