The Illusion of the Autonomous AI Developer:
Lessons from Generative AI Game Development
For their master thesis in Informatics, University of Skövde-students Dániel Kapros and Marton Marczis investigated whether generative AI actually can completely take over game development from human hands.
Abstract
AbstractGenerative artificial intelligence is increasingly presented as a transformative force within creative production, including game development. In theory, current AI systems appear capable of supporting, accelerating, or even replacing many individual tasks within a game production pipeline, from ideation and writing to programming, visual asset generation, audio production and post-production support. This essay summarises the findings of an experimental case study in which a small game prototype was developed using commercially available generative AI tools as the primary production agents. The study investigated the extent to which such systems could operate as an “autonomous developer” across a complete game development pipeline. Central findings revolve around not that generative AI is unable to support game development, but that its apparent autonomy is curated: the human developer’s role shifts from direct creator to supervisor, editor and pipeline integrator.
Keywords: generative AI, game development, autonomous developer, human intervention, AI-assisted production, curated autonomy
1.Introduction
IntroductionThe rapid development of generative AI has produced a strong belief that many forms of creative production are entering a new stage of automation. Game development is one of the most relevant fields in which to examine this claim, because games are inherently multi-disciplinary products. Even a small game may require writing, design, programming, visual art, animation, sound design, music, testing and integration. For this reason, game development provides a useful testing ground for the practical limits of generative AI (Daneels 2025). If AI systems are able to support or perform tasks across many different domains, then a game production pipeline offers a clear way of examining whether those systems can function not only as tools, but as something closer to an autonomous developer. The idea of an “AI game developer” is attractive because many individual AI tools already appear powerful in isolation. Large language models can generate design documents, mechanics, dialogue, code and prompts for other systems. Image generators can produce concept art, logos, textures and stylistic references. Text-to-3D systems can create static models from descriptions, and some even support Image-to-3D workflows using reference images. Text-to-audio systems can generate music, sound effects and voice lines. Code generation tools can assist with implementation and debugging. Taken individually, these systems suggest that large parts of a small production pipeline can be automated (Anjum, Li, Law, Charity, & Togelius 2024).
However, game development is not merely a collection of independent tasks. The challenge lies in making those outputs work together. A model must fit the chosen art direction. A texture must match the object to which it is applied. A script must work inside a game engine. Audio must support the intended atmosphere. A mechanic must be understandable, functional and integrated into the overall player experience. And above all else; all of these small, individual parts must also be put together – the game constructed. The pipeline is therefore not simply about production, but about coherence. This makes the question of AI autonomy much more complicated than asking whether AI can “make assets” or “write code”. The case study summarised here (Kapros & Marczis 2026) investigated the following research question:
“To what extent can generative AI systems autonomously execute a complete game development pipeline with minimal human intervention?”
To answer this question, a small game prototype was developed using generative AI tools as primary production agents. The aim was not to produce a commercial game, nor to prove that AI could replace professional developers. Instead, the study examined where AI systems succeeded, where they failed, and what kinds of human intervention became necessary during the process. The central contribution of the study lies in its intervention-based analysis: human intervention was not treated as a side effect, but as the main indicator of where AI autonomy breaks down.
2.Methodological Approach
The study followed an experimental case study format centred on the creation of a game artefact. This artifact was a small game prototype designed to represent a compact but meaningful development pipeline, with the intended scope limited to a short gameplay experience. This combination of scope and limitations allows the project to include multiple production areas while remaining feasible within the available time and resources.
A range of publicly accessible generative AI tools were selected according to criteria such as availability, cost, technical capability and compatibility with the selected game engine. The study deliberately avoided custom-trained or enterprise-level AI systems, since the aim was to investigate what could be achieved using tools available to ordinary developers or small teams. This decision was important because the study was not testing a theoretical maximum of AI capability, but a practical workflow that future developers might realistically attempt. To this end, the human role was restricted as much as possible. The developers were allowed to prompt AI systems, select from generated outputs, integrate assets into the game engine and perform unavoidable technical operations. However, manual creation or restructuring of core artefacts was treated as a stronger form of intervention. The distinction between acceptable human input and problematic intervention became central to the study.
To measure this, the project developed two connected documentation frameworks. The first was the Quantitative Intervention Log (QIL). This tracked measurable aspects of the process, including prompt count, human correction count, manual editing time and AI output acceptance rate. While these metrics were not as deeply detailed, their patterns could suggest certain conclusions regarding how interventions affected the development process.
The second was the Qualitative Intervention Classification & Evaluation (QICE). This classified interventions according to severity, using categories such as minor adjustment, structural correction and full replacement. With the categories present, the “Evaluation” part was performed using a thematic analysis on the content of interventions.
By focusing on interventions, the study revealed the difference between perceived AI efficiency and practical AI efficiency. Generative AI often appears fast because it can produce outputs in seconds or minutes. However, the time saved during generation may reappear later as validation, correction or integration work. For example, a 3D model generated quickly by AI may still require decimation, mesh cleanup, texture correction, scale adjustment or animation repair before it can function inside a game engine. Similarly, code may be generated quickly but still require human inspection to identify missing references, incorrect assumptions or poor architectural choices (Yetiştiren, Özsoy, Ayerdem & Tüzün 2023).
3. Intervention as a Measure of AI Autonomy
The most important methodological decision in the study was to treat human intervention as the primary measure of AI autonomy. This is significant because many discussions of generative AI focus on the quality of final outputs (Jie, Shan & Chung 2023; Šarčević, Dorić, Ivančević, Banić & Buljat 2024). While output quality matters, it does not fully explain the development process. A usable asset may not have been created on the first attempt. A working script may depend on extensive debugging. A visually impressive concept may not translate into a functional game-ready model. In such cases, the final product “hides” the amount of human labour required to make it actually usable.
Turning attention to the results of the study; QIL data reveals some interesting intervention patterns; many of these varied strongly between production areas. Programming generated the highest number of prompts and corrections, suggesting that code-related tasks required frequent interaction and adjustment. Compared with the manual editing time however; it becomes easy to conclude that these interventions were small and fast to resolve. Art shows the complete opposite trait: It required fewer prompts than programming but demanded much more manual editing time, particularly because generated models often needed correction before they could become usable game assets. Audio – despite being another creative-focused area – by contrast performed surprisingly well: although some files required cropping or adjustment, the generated outputs were generally accepted and compatible with the project. Similarly, Worldbuilding required almost no correction; suggesting that text-based creative ideation was one of the strongest areas for the AI systems.
This distribution is important because it shows that “AI capability” cannot be discussed as a single category. The systems were not uniformly strong or weak – they performed very differently depending on the production domain. Creative ideation, worldbuilding and audio generation produced relatively strong results. Technical integration, 3D asset preparation and complex programming produced more frequent difficulties. This suggests that the practical use of AI in game development depends heavily on which part of the pipeline is being automated.
4. Prompt Dependency and the Autonomy Paradox
One of the clearest patterns in the study was prompt dependency. Generative AI systems were highly sensitive to the way tasks were described. Vague prompts often produced vague or generic results. More detailed prompts produced stronger outputs, but this created a paradox: the more precise the prompt had to become, the less autonomous the AI system actually became.
This was especially visible when ChatGPT acted as the central design and coordination agent. The model was able to generate ideas, structure game design decisions, define narrative elements and produce prompts for other AI tools. In this sense, it operated as a form of project manager or design assistant. However, it still depended on human framing. The developers had to define the scope, constrain the game idea, decide which suggestions were viable, identify when the model overreached and redirect the process when necessary.
This reveals an important limitation of AI autonomy. The AI can generate within a problem space, but humans still define and maintain that problem space. In game development, this matters because the production pipeline is full of implicit constraints. A human developer understands time limits, technical feasibility, engine compatibility, asset workload, genre conventions and team skill levels. An AI system may refer to these constraints if prompted, but it does not reliably maintain them on its own across a long production process. Thus, prompt engineering becomes a new form of production labour. It does not remove the developer from the pipeline; it changes the developer’s role from direct maker to instruction designer and output evaluator.
5. Pipeline Bottlenecks and Integration Failure
Another major pattern found in the study was not the lack of AI output – but rather the lack of quality and coherence. This became visible in what can be called the integration bottleneck. The QIL data already hinted at how some of these interventions came to affect the study; this pattern reveals a much deeper consequence.
Because of how the systems work, each AI tool operates within its own domain. ChatGPT could design and write. Meshy could generate models. ElevenCreative could generate sounds. Copilot would write code. Not all tasks were straightforward however – 3D model generation was one of the clearest examples. AI systems could generate visually recognisable models, but these were not automatically production-ready. Metrics like acceptable topology, scale, orientation, texture mapping, material compatibility and performance characteristics are all necessary qualities; not all of which the AI could ensure. Even when a generated model looked usable at first glance, it often required correction before it could function in the game. This created a bottleneck where fast generation did not necessarily translate into fast production.
Programming and other technically oriented topics showed a different kind of limitation. Code generation tools were helpful and frequently produced partially correct solutions. However, they also introduced errors, misunderstood instructions, relied on missing references or generated solutions that did not fit the project’s structure. The result was not complete failure, but unstable reliability: AI-generated code could accelerate development, but only under human supervision – which in much the same way, introduced an expenditure in time from the time saved on generation.
Still remains the biggest limitation of all however: the lack of integration into the game. Due to operating individually, none of these systems truly understood the project as a whole. The output of one system often needed to be translated, adapted or repaired before another system or the game engine could use it, forcing human developers to be responsible for maintaining continuity between tools. As there was no AI available which could work with the game engine directly, that task also fell to human developers. This is a crucial insight for future AI-assisted game development. The problem is not only tool capability, but tool interoperability. An AI-generated model may not match the needs of an AI-generated animation. An AI-generated mechanic may not be supported by the current code structure. An AI-generated narrative direction may imply assets that are too difficult to produce within the available time. And the individual outputs, regardless of quality, must still be integrated into the central game engine. These issues are not failures of isolated generation; they are failures of production coordination.
The study therefore suggests that current generative AI systems are better understood as specialised production agents rather than as a unified autonomous developer. They can contribute strongly within bounded tasks, but they do not independently maintain the relationships between tasks. In traditional game development, this coordinating function is performed by producers, leads, designers, programmers, artists and technical directors. In the AI-driven pipeline, that coordinating role did not disappear. It remained with the human developers – which introduces practical implications. A developer attempting to build a game with AI should not only ask which tools can generate assets. They should ask how those assets will move through the pipeline. What formats will be produced? Can they be imported into the engine? Do they need cleanup? Are they consistent with previous outputs? Can they be animated? Can the generated code support the intended mechanic? How many attempts are needed before a result becomes usable? These questions determine whether AI accelerates development or creates new forms of hidden labour.
6. The Illusion of Autonomy
The single-most important conceptual outcome of the study is the illusion of autonomy. At a surface level, the project appeared to demonstrate a high degree of AI-driven production. AI systems generated ideas, design material, narrative content, code, visual assets, audio and other components. However, closer analysis showed that this autonomy was never complete. It was continuously framed, corrected and maintained by humans.
This does not mean that the AI tools were ineffective. On the contrary, many of them were highly useful. The issue is that usefulness should not be confused with autonomy. A system may be powerful, fast and productive while still depending on human oversight. In this case study, the AI tools could not independently understand the full state of the project, evaluate all outputs against production requirements, maintain long-term consistency or solve integration problems without human assistance. A useful way to describe this condition is curated autonomy. The AI systems operated within a space of partial autonomy, but that space was curated by human developers. The humans did not necessarily create every asset manually, but they selected outputs, refined prompts, corrected errors, maintained direction, integrated files and judged whether the result was acceptable. The human role shifted from creator to curator, supervisor and integrator.
This shift is important. It suggests that generative AI does not simply replace human work; it redistributes it. Some forms of labour are reduced, especially early ideation and first-pass generation. Other forms of labour increase, especially validation, correction and integration. The developer becomes less of a traditional maker in some moments, but more of a production editor and systems coordinator. This is not full automation. It is a new form of human-AI collaboration, where the AI produces material and the human maintains coherence. The illusion of autonomy is therefore not a failure of the project, but one of its most valuable findings. It clarifies why AI may appear more autonomous than it actually is. If one looks only at generated outputs, the AI seems highly capable. If one looks at the full production process, the dependence on human intervention becomes visible.
7. Implications for Future Developers
For developers interested in using AI to make games, the findings suggest several practical expectations:
First, recognising the strengths and weaknesses of AI is key to accelerating development. AI is, for example, highly useful for ideation and early production. It can generate concepts, narrative directions, mechanics, visual references, sound effects and code suggestions quickly. This makes it especially valuable for small teams or individual developers who need to explore ideas rapidly. It does not however remove the need for expertise. In fact, expertise becomes necessary in a different way. Developers must know whether an output is usable, whether a script is safe, whether a model is game-ready, whether an animation fits, or whether a design suggestion is feasible. Without this knowledge, AI-generated outputs may appear acceptable while hiding serious production problems.
Second, AI introduces new bottlenecks. A developer may generate more material than they can evaluate or integrate. This can create a situation where production speed increases at the front end, but slows down later due to cleanup and correction. The bottleneck moves from creation to validation. Tool selection is also critical – different AI systems perform at various qualities across domains. A tool that performs well for audio may not help with models. A language model may be excellent for worldbuilding but unreliable for engine-specific code. A model generator may produce visually appealing objects that still require extensive technical repair. Developers should therefore treat AI pipelines as specialised toolchains rather than single unified solutions.
8. Conclusion
This case study set out to examine whether generative AI systems could autonomously execute a complete game development pipeline with minimal human intervention. The answer is mixed but clear: AI systems can perform many individual tasks within game development and can significantly accelerate certain parts of production, but may slow down other parts – the time gained in generation speed can easily be offset by time required for validation. Above all else; they do not yet function as autonomous developers in a full production sense. AI is currently better understood as a production accelerator than an autonomous developer. It can help small teams expand their capabilities, but the human developer remains central to decision-making, correction and final assembly.
The core limitation is not simply output quality, but pipeline coherence. Current AI systems can generate components, but they do not reliably understand how those components must interact within a complete game. As a result, human intervention remains necessary for framing, prompting, selecting, correcting, validating and integrating outputs. The role of the human developer does not disappear; it’s transformed. The study therefore suggests that the future of AI-assisted game development may not be immediate full automation, but curated autonomy. Generative AI can act as a powerful semi-autonomous production partner, but only within a human-supervised workflow. The promise of AI in game development is real, but so are its limits. For now, humans still hold the keys to coherent game production.
As an added layer of irony, this very text was produced in much the same way: LLMs were asked to write a concise draft based on the contents of the thesis; which was then quality controlled and mistakes corrected for by its human authors – bringing the conclusion and findings together in a roundabout way.
References
Anjum, A., Li, Y., Law, N., Charity, M. & Togelius, J. (2024). The ink splotch effect: A case study on chatgpt as a co-creative game designer. In Proceedings of the 19th International Conference on the Foundations of Digital Games. New York, USA, 21-24 May 2024, pp. 1-15. doi:10.1145/3649921.3650010
Daneels, R. (2025). Exploring the opportunities and risks of generative AI for game development: Insights from the Belgian game industry. In Proceedings of AI4HGI ‘25, the First Workshop on Artificial Intelligence for Human-Game Interaction at the 28th European Conference on Artificial Intelligence (ECAI ’25). Bologna, October 25-30, 2025.
Kapros, D. & Marczis, M. (2026) Autonomous Developer: Case study of game development using generative AI models with minimal human interference. Master’s Thesis. Faculty of Information Technology. University of Skövde.
Jie, P., Shan, X. & Chung, J. (2023). A comparative analysis between< Leonardo. Ai> and< Meshy> as AI texture generation tools. International journal of advanced culture technology, 11(4), pp. 333-339. doi:10.17703/IJACT.2023.11.4.333
Šarčević, I., Dorić, T., Ivančević, A., Banić, D. & Buljat, P. (2024). CAPABILITIES OF AI IN TEXT-TO-3D MODEL GENERATORS FOR MECHANICAL COMPONENTS DESIGN. In Proceedings of 12th International Symposium on Graphic Engineering and Design GRID 2024. 2024, pp. 405-410. doi:10.24867/GRID-2024-p44
Yetiştiren, B., Özsoy, I., Ayerdem, M. & Tüzün, E. (2023). Evaluating the code quality of ai-assisted code generation tools: An empirical study on github copilot, amazon codewhisperer, and chatgpt. arXiv. doi:10.48550/arXiv.2304.10778
Contact
With questions about Game Tech Academy, please contact Luisa Geitmann-Mügge at luisa.geitmann-mugge@aalborg.dk.
