Why I'm Pausing My Digimon World Project

I started this project with a simple goal: recreate one of my favorite childhood memories while learning game development.

It wasn't about shipping a game. It wasn't about productivity. It was an excuse to build something for the joy of building it.

For most of the project, AI felt like a very good pair programmer. I relied on my 10+ years as a software engineer to design the systems, then asked questions whenever I encountered something specific to Godot or game development.

It was collaborative. I stayed in control. More importantly, I learned.

Somewhere along the way, that changed.

The digivolution sequence is where I crossed a line without noticing it.

For this first digivolution sequence, I chose Agumon evolving into Greymon. The original animation lasts around thirteen seconds. Agumon turns inside a transparent sphere while green scanner rails form beneath him. His model breaks into fragments. Small energy spheres appear and overlap. A bright orb grows into a full-screen flash, then Greymon materializes in his place.

Recreating it required several independent effects: the scanner rails, the energy spheres, the focus lines, the mesh shatter, the flash burst, and the final materialization.

It was exactly the kind of technical challenge I wanted from this project.

At first, I approached it as I had approached everything else. I studied the reference, divided the sequence into components, and tried to understand how each one worked.

Then I started delegating more.

I downloaded a video of the original sequence, extracted it at 30 frames per second, and generated a timestamped contact sheet. I recorded the Godot version and produced the same sheet so both animations could be compared frame by frame.

The camera was too low. Agumon faced the wrong direction. The scanner rails were too large. Their groups moved together instead of rising one after another. Their thickness changed as they scaled. The bubbles appeared at the wrong times and did not overlap like the original.

For every difference, I asked the AI to analyze the reference and change the implementation.

It would update the scripts, expose new editor properties, adjust the scene, and explain what had changed. I would open Godot, scrub through the timeline, record another video, generate another contact sheet, and repeat.

Describe. Wait. Review. Correct.

Technically, it was a good workflow.

It was also where I stopped making the effect.

My role slowly shifted from builder to reviewer. I was no longer asking how to produce a particular visual result. I was pointing at differences and asking a machine to remove them.

The scanner rails made this especially obvious.

We iterated on their spacing, thickness, center size, elevation distance, timing, brightness, and rotation. Eventually, I asked for all the important values to be exposed in the editor so I could tune them myself.

That part felt better.

Moving the values, scrubbing the timeline, and seeing how one property affected the whole effect gave me some understanding again. It also made me realize how far I had moved away from that process.

The result is technically interesting. The sequence has reusable VFX components, deterministic mesh shattering, an editor-scrubbable timeline, configurable sphere choreography, and a manual preview scene.

The scanner rails now behave well. The energy spheres are close to the reference. The flash and materialization still need work.

But whether the sequence is finished is no longer the important question.

Even if I completed it, I don't think it would mean much to me.

Not because the result is bad.

Because I don't feel like I made it.

I had become a project manager for a machine that happened to write code.

At first, I told myself this was simply another form of engineering. We automate repetitive work all the time. Boilerplate is repetitive. Testing is repetitive. Comparing hundreds of frames is repetitive. Why not automate more of it?

That reasoning makes sense when the goal is efficiency.

But efficiency was never the goal of this project.

The more I optimized for getting things done, the less I enjoyed doing the thing.

It became strangely passive.

At work, removing friction is usually valuable. In a personal project built around learning, the friction is often the point.

I wanted the wrong turns.

The experiments that fail.

The evenings spent chasing a bug that eventually teaches me something.

The small moment when an effect finally works because I understand why it works.

Those moments are the reward.

The finished game is just a souvenir.

Don't get me wrong, I still think AI is an incredible tool.

I love using it to explore topics I don't understand. I like asking it to challenge an architectural decision or point out flaws in my reasoning. It can be an excellent teacher when I remain actively involved.

What doesn't work for me is staying one level above the implementation.

I don't enjoy reviewing hundreds of generated lines and trying to determine whether they are correct. I could read every line. I probably should.

Eventually, I stop.

At that point, I am no longer learning. I am supervising.

Code review was never the part of software engineering I loved most.

Neither was managing people.

It turns out I don't particularly enjoy managing a machine either.

AI did not take control of the project. I gave it control because doing so was convenient. This is not a criticism of the tool. It is a boundary I failed to set for myself.

So I am pressing pause on the project.

Not because AI ruined it.

Because I lost sight of why I started it.

If I return, I want to use AI differently. I want to write the first attempt myself. I want to ask for explanations before implementations. I want it to review decisions I have made, not make every decision for me.

Most importantly, I want to notice when the process becomes a loop of describing, waiting, and reviewing.

That is when I need to stop and put my hands back on the work.

I want to make games because making games is fun.

Creating something myself, even imperfectly, is deeply satisfying. I would rather build something smaller that I understand than something impressive that does not feel like mine.

Maybe I will return to Digimon World with better boundaries.

Maybe not.

Either way, I don't want to optimize the joy out of making things.