• 

• 

• 

• 

• 

• 

About Dragon Cores

Inspiration

Dragon Cores began with a simple question:

Could a solo developer build a commercial-quality RPG by combining disciplined software engineering with AI collaboration?

I've always loved turn-based RPGs and character collection games, but I wanted to create something with my own identity rather than simply copying existing games.

The result is Dragon Cores, a fantasy RPG where every hero begins without an elemental affinity and can permanently awaken into one of three Dragon Core paths, changing their combat role and abilities while preserving their identity.

From the beginning, my goal wasn't just to make a game—it was to build a maintainable game engine that could continue growing long after the first playable version.

How I Built It

Dragon Cores is being developed in Godot using a data-driven architecture.

Instead of embedding gameplay rules inside UI or animation code, I separated the project into independent systems responsible for combat, progression, presentation, and content. Hero definitions, skills, encounters, and progression are all data-driven, so new content can be added without rewriting gameplay systems.

One of the biggest architectural goals has been separating gameplay from presentation. Combat determines what happens, while presentation determines how it looks. This allows static sprites, frame animations, and skeletal animations to share the same battle pipeline without changing combat logic.

Throughout development, I used Codex as an engineering partner rather than a code generator.

Instead of asking it to “build the game,” I used it to:

• Audit repository architecture before major milestones
• Critique proposed designs
• Identify coupling between systems
• Generate implementation plans
• Review Git safety before large changes
• Suggest reusable interfaces
• Create automated test plans
• Produce physical validation checklists
• Review milestone boundaries before implementation

This workflow helped me think through architectural decisions before writing code and kept individual milestones focused and testable.

Challenges

The biggest challenge wasn't writing combat—it was learning how to design software that could continue growing.

As a first-time game developer, I quickly discovered that every new feature affected multiple systems unless the architecture was carefully designed. Early in development, I spent significant time refactoring responsibilities between runtime state, immutable definitions, presentation, UI, and game management.

Another major challenge has been balancing long-term flexibility with short-term progress. It is easy to continue improving architecture forever, but a game also needs visible progress.

Working with Codex encouraged me to define clear milestone boundaries so that each iteration left the project in a playable state before moving on to the next feature.

The current milestone focuses on introducing skeletal character animation through a reusable presentation layer without changing the underlying combat engine. Seeing that integration work validated many of the architectural decisions made earlier in the project.

What I Learned

This project fundamentally changed how I think about software engineering.

I learned that architecture isn't about making code complicated—it's about making future work easier.

I also learned that AI works best as a collaborative engineering partner rather than an autopilot. Some of the most valuable conversations weren't about generating code at all. They were about discussing trade-offs, reviewing designs, identifying risks, planning implementation strategies, and validating ideas before investing time in development.

Rather than replacing the creative process, Codex became a technical collaborator that helped me reason through difficult engineering problems while leaving the design decisions in my hands.

Looking Forward

Dragon Cores is still under active development, but the foundation now supports continued expansion through reusable systems, automated testing, and modular presentation layers.

This project represents my vision of how AI can empower independent developers—not by replacing creativity, but by making professional engineering practices accessible to solo creators.

Built With

• ai-assisted
• chatgpt
• codex
• gdscript
• godot
• gpt-5.6
• openai