Every game studio is experimenting with AI tools. Most of the discourse around AI in game development falls into two camps: breathless enthusiasm ("AI will replace game developers") or dismissive scepticism ("AI code is all rubbish"). Neither is accurate.
We have been integrating AI tools into our development workflow at Ocean View Games for over a year. Some tools have saved us genuine time. Others looked promising but created more work than they saved. A few that we initially dismissed have become indispensable.
This post covers what we actually use, what we stopped using, and the principles we have developed for deciding when AI helps and when it gets in the way.
Where AI Saves Us Real Time
Code review and bug detection
This is the single highest-value use of AI in our workflow. Before any pull request is merged, we run it through an AI-assisted review that checks for common Unity-specific issues: null reference risks, potential memory leaks from unsubscribed events, incorrect coroutine patterns, and serialisation mistakes that only surface at runtime.
The key insight is that AI review does not replace human review. It handles the tedious pattern-matching work (did you forget to unsubscribe from that event? Is this allocation happening inside Update?) so that human reviewers can focus on architecture, readability, and whether the code actually solves the right problem.
On the Domi Online project, AI-assisted review caught a subtle FishNet serialisation issue where a custom struct was not implementing the correct read/write interface. A human reviewer would likely have caught it eventually, but it would have required stepping through the networking code mentally. The AI flagged it in seconds because it had seen the pattern before.
We estimate AI review saves 2 to 3 hours per week across the team, primarily by catching issues that would otherwise surface during QA or, worse, in production.
Boilerplate and scaffolding
Game development involves a surprising amount of repetitive code. ScriptableObject definitions, editor inspectors, serialisation wrappers, basic UI controllers, and event system boilerplate are all structurally similar across projects.
AI is genuinely good at generating this kind of code. When we need a new ScriptableObject type with a custom editor inspector, an AI assistant can produce a working first draft in seconds that would take 15 to 20 minutes to write by hand. The output needs review and usually some adjustment, but the net time saving is real.
We built this into our workflow by maintaining a set of prompt templates for common Unity patterns. "Generate a ScriptableObject for [X] with fields [Y] and a custom inspector that [Z]" produces usable code roughly 80% of the time.
Documentation and commit summaries
Maintaining documentation under deadline pressure is a chronic problem in game development. We use AI to generate initial drafts of code documentation, API references, and commit summaries. A developer finishes a feature, runs the AI over the changed files, and gets a draft summary that captures what changed and why.
The drafts are not publication-ready. They need editing for accuracy and context that the AI does not have. But starting from a draft is significantly faster than starting from a blank page, and it means documentation actually gets written rather than being perpetually deferred.
Test case generation
When we write a new system, we ask AI to suggest test cases we might have missed. This is not about generating the test code itself (AI-generated tests often test the implementation rather than the behaviour, which makes them brittle). It is about generating a list of edge cases and scenarios.
For the 64-bit progression system in Domi Online, AI suggested testing with values near the overflow boundary of both 32-bit and 64-bit integers, which we had planned, but also with negative values and with concurrent modifications from multiple systems, which prompted us to add atomic operation tests we had not considered.
The value here is breadth of thinking, not depth. AI is good at generating comprehensive lists of "what could go wrong" scenarios because it draws from patterns across millions of codebases.
Where AI Wastes Our Time
Complex game logic
AI code generation falls apart when the problem requires understanding game design intent. A pathfinding system, a combat damage calculator, or a procedural generation algorithm needs to encode design decisions that are specific to your game. AI generates plausible-looking code that compiles and runs but implements the wrong behaviour.
We tried using AI to generate the cellular automata rules for Empires Rise's map generation. The output looked reasonable but produced maps that were technically valid and completely unplayable, with no chokepoints, poor resource distribution, and uniform terrain. The algorithm needed to encode design intent (where should mountains cluster? How dense should forests be?) that the AI had no way to infer.
For complex game logic, we write the code ourselves and use AI only for review after the fact.
Networking and multiplayer code
This is where AI-generated code is actively dangerous. Multiplayer networking requires server-authoritative validation, careful state synchronisation, and security considerations that AI consistently gets wrong. AI will generate client-authoritative patterns by default because they are simpler and more common in tutorials. In a production multiplayer game, client-authoritative code is an invitation to cheating.
We have a firm rule: no AI-generated code in our networking layer. Every line of FishNet synchronisation code, every server validation routine, and every anti-cheat check is written and reviewed by developers who understand the security implications.
"Creative" code generation from vague prompts
The worst use of AI in our experience is asking it to "build a feature" from a vague description. "Make the enemies smarter" or "add a combo system" produces code that appears to work in isolation but does not integrate with the existing architecture, does not follow the project's conventions, and creates technical debt that takes longer to clean up than writing the feature from scratch.
AI works well when the problem is well-defined and the scope is narrow. It works poorly when the problem is ambiguous and the scope is broad.
What We Stopped Using
AI-generated art assets. We experimented with AI image generation for placeholder art during prototyping. The outputs were visually interesting but stylistically inconsistent, and they created a misleading impression of final quality for clients reviewing prototypes. We returned to simple geometric shapes and colour-coded placeholders, which set more honest expectations.
AI-generated commit messages. We tried having AI generate commit messages automatically. The messages were technically accurate ("Updated PlayerController.cs") but lacked the context that makes commit messages useful ("Fixed edge case where jumping during dash cancelled momentum"). Good commit messages require understanding intent, not just change.
AI for estimation. We briefly tried using AI to estimate task durations based on historical data. The estimates were consistently too optimistic because the AI weighted the straightforward past tasks more heavily than the complex ones. Human estimation with calibrated pessimism remains more accurate for our projects.
Principles for Using AI in Game Development
After a year of experimentation, we have settled on a few guidelines:
Use AI for verification, not generation, on critical code. Let humans write the game logic, networking, and security-sensitive code. Use AI to review it for issues that pattern-matching catches better than human attention.
Use AI for boilerplate and scaffolding. Any code that is structurally similar to code you have written before is a good candidate for AI generation. Custom editors, data classes, serialisation wrappers, and basic UI controllers all benefit.
Never ship AI-generated code without human review. Every line of AI output goes through the same review process as human-written code. AI is a first draft, never a final product.
Be specific in your prompts. "Write a Unity ScriptableObject for weapon stats with int damage, float fireRate, and enum WeaponType, with a custom editor that shows a preview sprite" produces useful code. "Make a weapon system" produces a mess.
Track where AI actually helps. We log which AI-assisted tasks save time and which ones create rework. This data prevents the sunk cost fallacy of continuing to use a tool because you have invested in learning it, even when it is not helping.
Looking Forward
The areas we are watching most closely:
Automated playtesting. AI agents that play your game and report bugs, balance issues, and exploits. This is not yet production-ready, but the prototypes are promising enough that we expect it to become a standard part of QA pipelines within a few years.
Build and pipeline optimisation. AI that analyses your Unity project and suggests build size reductions, unused asset removal, and compile time improvements. Some of this exists already in basic form, and we expect it to become more sophisticated.
Localisation quality checking. Not AI translation (which still produces awkward results for game dialogue) but AI that flags potential issues in human translations: text that overflows UI elements, cultural references that do not translate, or terminology inconsistencies across a language.
The tools are improving rapidly. What did not work six months ago may work today. The key is to evaluate regularly, be honest about what helps and what does not, and never let AI tools substitute for the creative and technical judgement that experienced developers bring to every project.
Want a development team that uses AI to improve quality without cutting corners? At Ocean View Games, we combine AI-assisted workflows with experienced engineers who make the final calls. Get in touch to discuss your project.
