An Ordinary Person’s Experience: Tackling Game Development with Generative AI, Even Without Any Prior Game Development Experience:A story set in 2026
2026年4月13日
In my previous article, I introduced a prototype of a game I created using generative AI.
In this article, I’ll share my personal experience—specifically, what actually happened during the development process and how far I was able to get as a complete novice in game development.
The focus of this article is not to compare the merits and demerits of each tool.
Rather, this is an article reflecting on my personal experience to answer the question: To what extent could a game development novice create something that actually feels like a game by using generative AI?
An overview of the completed game and the demo page are summarized in the introduction article.
My Background as a Beginner
First, I’ll outline my background.
- No prior experience in game development
- No prior experience in 3D data modeling
- However, I have 17 years of professional experience as a systems engineer, IT help desk specialist, and systems administrator
- About 3 years of experience using AI tools
In other words, I’m not completely new to IT.
However, this was my first time actually making a game.
I believe this background is significant.
This is because in many situations where I was able to get through this project, the foundation was not so much game development knowledge, but rather the instincts I acquired through IT work—such as setting up environments, troubleshooting errors, and being vigilant about specification discrepancies.
On the other hand, simply having the program run is not enough to make a game work.
It’s necessary to shape the game by incorporating visuals, sound, world-building, playability, and even presentation—and that was truly a challenge for a complete novice.
Time Taken to Complete the Prototype
As a rough estimate of production time, it took approximately 70 hours for the HTML version and about 90 hours for the Godot version to reach a playable prototype stage. This is not a precise measurement but a rough estimate based on the number of days and hours worked. Note that this does not include the time spent preparing for the demo release; it refers to the time from when I started building until the prototype was in a playable state after repeated revisions. In my experience, the Godot version, being modular in structure, presented more challenges during revisions and adjustments, and I feel that this difference was reflected in the time it took.
My Experience with the HTML Version
Challenges
The HTML version progressed quite quickly at the very beginning.
I remember feeling that “this might actually work” because it took far less time than I had imagined to get something up and running.
However, things weren’t easy from there on out.
What I struggled with most was getting the visuals to look exactly as I intended. Even when I specified specific processing steps, the visual fidelity was low; for instance, the receipts the ATM dispenses initially ended up looking like paper airplanes. It wasn’t enough for it to simply work—it took a significant amount of effort to make the visuals look “realistic.”
Sound was another area where I struggled.
I had to rewrite the audio generation program for each stage multiple times. The issues weren’t just with the code itself; sometimes the audio wouldn’t play due to where it was implemented, and even when it did play, it was often too hard for the player to hear. It’s not enough for the sound to simply play; we had to ensure it felt natural to the human ear, so I felt this was an area where relying solely on AI wasn’t sufficient.
Additionally, as the code grew larger, it became increasingly difficult to have it output the entire text continuously.
While we could generate everything at once up to a certain scale, as the number of lines increased, the output would often stop midway or omit necessary processing. From this point on, simply telling it to “output everything” no longer worked, and detailed incremental instructions became necessary.
Observations from Use
What I noticed while using it was that generative AI struggles in some situations to accurately grasp the final visual form based solely on text.
Especially for parts related to appearance, providing instructions while showing an image made it easier to achieve the intended result, and the accuracy of both input and output improved compared to using text alone. Color schemes also required more than just simple color specifications; adjustments were needed that included gloss and texture.
Another significant observation was that the AI tends to prioritize “working code” and lacks a strong optimization mindset.
Even for the same process, I got the impression that unless the human designer incorporates lightweight and high-speed design principles from the start, the implementation tends to become heavy and slow. I clearly understood that ‘working’ and “running smoothly” are two different things.
Effective Workflow
As conversations grew longer, responses became slower, and the system often stopped midway.
However, starting a new session at a natural breakpoint and resubmitting the entire code at that point tended to make things more stable.
Also, instead of generating the full text every time, specifying additions, deletions, before-and-after changes, reasons for the work, and target sections as differences made it easier to proceed even with large codebases.
With the HTML version, since it’s easy to grasp the whole picture on a single page, it was easier to see exactly what needed to be changed, and I felt the conversation flowed more smoothly than with the modular approach.
Experiences with the Modular Approach
Challenges with the Modular Approach
In modular development like Godot, we could proceed by outputting the entire code during the initial, lightweight stages, but as the processing load increased, outputting the full text tended to stall midway.
From that point on, it became a series of incremental revisions, and if the developer didn’t understand the structure themselves, it became impossible to keep up. In modular development, I felt that rather than leaving everything to the AI, humans need to proceed while maintaining an understanding of the big picture.
What stands out most in my memory is the implementation of the background music (BGM).
No matter how many times I revised the code, it didn’t improve. When I traced the cause, the problem wasn’t with the program itself, but with the file format I was using for the BGM. It wouldn’t play properly with wav, and it wasn’t until I switched to ogg that it finally played. I realized the importance of humans noticing when something is “off” and correcting the course, because generative AI can sometimes veer off track once it goes astray and continue moving in the wrong direction.
The same thing happened with visual adjustments.
The initial obstacles generated were quite simplistic: the airplane had unnatural wings, the juice looked like a stick, and the candy resembled little more than a colored box. By repeatedly adjusting these elements to convey their characteristics, we finally began to create a game that was visually clear and easy to play.
Insights from the Modular Approach
In the modular approach, it was crucial to clearly specify exactly what to change and where when adding, removing, or replacing parts of the program.
Even if the output seemed correct at first glance, upon later inspection, we sometimes found that parts of the generation were missing, so we couldn’t feel confident unless we provided detailed instructions.
However, what I strongly felt during this process was that the very act of developing a game using AI also served as a way to hone debugging skills and structural understanding.
While the AI made things easier, the experience of reviewing its output, making judgments, and making corrections directly translated into improved development skills. Compared to the old days of writing everything from scratch by myself, I feel that development speed has increased significantly.
Limitations I Encountered with the Modular Approach
When I shared the entire module and went through multiple rounds of feedback, there were instances where the AI noticed structural imbalances or processing bottlenecks.
However, for issues like BGM—where the root cause lay not in the code itself but in file formats or implementation conditions—the discussion would sometimes veer off track, leading to a series of irrelevant fixes. While generative AI is convenient, I felt that prioritizing and isolating problems still relies heavily on human judgment.
Additionally, I couldn’t ignore Godot-specific coding conventions, version differences, or UI variations.
Even when I provided the development environment details, it sometimes returned code with syntax errors, so I couldn’t trust it blindly and had to verify it with my own eyes at least once. While the modular approach is better suited for organized development, I felt that it also increases the difficulty for beginners trying to rely solely on AI.
Overall Summary
The Gap Between Initial Expectations and Reality
Before starting, I assumed that even with generative AI, the limit for beginners would be simple 2D games like Space Invaders or Pac-Man.
However, once I actually tried it, that assumption was overturned quite early on. The first step was surprisingly easy, and simply getting something functional up and running was much faster than I had imagined. Even without any game development experience, generative AI allows you to go from “nothing” to a “playable state” in one go. That speed of getting started was one of the things that surprised me the most this time.
However, the ease only lasted until the very beginning.
The more you build, the more issues—such as visuals, movement, sound, structure, and consistency—pile up all at once. Generative AI excels at laying the initial foundation. However, in the subsequent process of refining it into “what you actually want to create,” human understanding and judgment become crucial. In that sense, this experience taught me not that “generative AI can do everything automatically,” but rather that “even beginners can get started quickly, but the closer you get to completion, the more significant the human role becomes.”
Where Generative AI Shone
I felt generative AI was particularly strong in getting the initial prototype up and running and providing a large number of rough drafts for implementation.
Even for something that would take who knows how many years to write from scratch on my own, using generative AI allowed me to get it to the point where it functioned as a prototype in a short amount of time. This is huge. From the perspective of someone with no game development experience, the fact that it made me feel like “I can actually do this” was valuable in itself, but this time, I went beyond that and actually reached a stage where it looked like a real game.
I also felt that generative AI doesn’t just spit out code; its role changes depending on the user’s objectives.
It helped me organize my options when I wanted to think about implementation methods, served as a foundation for my work when I wanted to move forward, and helped me quickly create a rough draft when I had a clear idea of what I wanted to do. In other words, I feel that the strength of generative AI lies not in its versatility, but in its ability to amplify human intent.
Where Human Perseverance Was Needed
On the other hand, there were clearly situations where generative AI alone wasn’t enough.
The most challenging aspects were debugging and maintaining consistency. While it can generate code, when it comes to whether that code truly fits with the whole, whether it breaks other parts after being modified, or whether it works across different environments and versions, it suddenly becomes unreliable.
In fact, there were times when the AI itself would later point out issues with the code it had generated—such as “a definition is missing” or “there’s a duplicate function”—and I felt time and again that the momentum of the output and the stability of its consistency are two separate things.
Furthermore, as conversations grow longer, the burden on the human side increases.
Misreadings, oversights, and assumptions become more frequent, and there were times when we lost sight of the root cause of an error due to these factors. It’s not just a problem with generative AI; there are also difficulties on the human side when dealing with long texts. That’s why it was crucial to implement workflows such as breaking things down into segments, making incremental corrections, and reorganizing and resubmitting the existing code. While using generative AI certainly makes things easier, it doesn’t work if used carelessly; using it effectively requires persistence and organizational skills on the human side.
Where My IT Experience Came in Handy
What I realized once again this time was that even without game development experience, my previous IT work experience served as a solid foundation.
Whether it was understanding runtime environments, being vigilant about version differences, isolating errors, recognizing quirks in interfaces, or handling variations in tool specifications—I felt my past experience directly applied in areas separate from the game itself.
I believe the perspective of not just the program’s contents, but also “how to run that program” and “where to look for problems”, was a sense I could only have developed through my professional experience.
Conversely, I also felt that for someone with absolutely no IT experience, there’s an additional hurdle between having generative AI write the code and actually getting it to run.
What is a module? What is a development environment? What happens when versions differ? Without that foundational understanding, it’s easy to get stuck before you even start game production. Still, this experience demonstrated that even without game development experience, if you have an IT foundation, generative AI can be a very powerful tool.
Conclusion from a Beginner’s Perspective
To conclude from a beginner’s perspective, I believe that by using generative AI, even those with no game development experience can sufficiently reach the point of creating something that looks like a game.
At the very least, I feel we’ve entered an era where it’s realistic to aim to take an idea, bring it to life, test it, and present it as a playable prototype. This is a significant shift. Game development is no longer the exclusive domain of a select few experts; for anyone with a creative drive, the gateway to actually entering the field has widened considerably.
However, it’s not the case that anyone can create everything completely automatically.
As the scale increases, there are definitely areas where human persistence is required—such as consistency, debugging, understanding the environment, and refining the visuals. If your goal is to release a demo, as in this case, simply writing the code isn’t enough; you need to consider everything from testing the functionality to preparing the release environment and organizing how it will be presented.
Furthermore, if you’re looking to sell it on an app store, what comes next is no longer just about programming. A whole new set of practical tasks suddenly comes into play, including release procedures, app store submissions, legal compliance, terms of service, marketing, and ongoing improvements.
Even so, what I can clearly say from this experience is that generative AI has the power to turn a beginner’s challenge into a tangible reality.
Creating the “foundation” of a game has become far more realistic than before. However, the range of skills required varies greatly depending on whether you proceed to releasing a demo or take it all the way to sales. However, I definitely feel that generative AI has shortened the distance from taking that first step to actually shaping the project and releasing it to the world.
For me, generative AI was the force that turned “This might be impossible” into “Let’s just try to make it happen first.”
Demo Page Link
You can enjoy the actual game on this demo page.
Game Introduction Article
If you’d like to know the game’s overview and highlights first, please also check out the introduction article.
View the Game Introduction Article
Summary
What I realized through this experience is that while generative AI provides a powerful boost for beginners, it is not a magic tool that can handle everything from start to finish.
Nevertheless, there is no doubt that it brings the possibility of creating a “playable” game—even for complete beginners—much closer to reality.
