I Built GameDev Buddy for a Friend Who Kept Getting Stuck on What to Build Next

When you're learning game development, coming up with an idea is usually the easy part.

The harder question is:

"What should I actually build first?"

A friend of mine who is learning game development often had interesting game ideas, but those ideas could quickly turn into a huge list of features. It became difficult to decide what systems were actually necessary, what should come first, and what could be left for later.

So for the Hacktoberfest Weekend Challenge, I built GameDev Buddy.

It's a small local AI assistant that takes a game idea and turns it into a practical development plan.

What I Built

GameDev Buddy asks for four things:

• Game idea
• Game engine
• Experience level
• Biggest development problem

It then generates five things:

• Goal
• Core Gameplay Loop
• Recommended Systems
• Development Order
• Next Step

The idea is intentionally simple.

GameDev Buddy isn't trying to generate an entire Game Design Document or manage a complete production pipeline.

It's trying to answer one question:

"What should I build next?"

For example, a beginner making a top-down roguelike can describe their idea and receive a practical development order instead of immediately trying to build every system they can think of.

Demo

Here's a 1-minute demo of GameDev Buddy running locally with Gemma 3 4B and Ollama.

Code

GitHub: https://github.com/Mythiosss/GameDev-Buddy

The repository contains the complete frontend, FastAPI backend, Ollama integration, AI prompt logic, and tests.

How I Built It

I wanted to keep the project small and understandable, so the architecture is fairly straightforward:

Browser
   ↓
FastAPI
   ↓
Ollama
   ↓
Gemma 3 4B
   ↓
Structured JSON
   ↓
Browser

The frontend uses vanilla HTML, CSS, and JavaScript.

The backend uses Python and FastAPI.

For the AI, I used Gemma 3 4B through Ollama.

The user input is sent to the FastAPI backend, which builds a structured prompt for the model.

Instead of asking the model for an arbitrary block of text, the application requests a structured JSON response:

{
  "goal": "string",
  "core_loop": "string",
  "recommended_systems": ["string"],
  "development_order": ["string"],
  "next_step": "string"
}

The backend validates both the incoming request and the generated response before returning it to the frontend.

I also added error handling for invalid requests and cases where the Ollama service is unavailable.

Testing

I tested the application with both automated tests and realistic game-development scenarios.

The backend test suite currently passes:

10 tests passed

I also tested five different scenarios:

• A beginner 2D platformer
• A top-down roguelike
• An over-scoped open-world RPG
• A combat design problem
• A beginner Unreal Engine horror game

All five scenarios produced valid structured responses.

I also tested invalid requests, including:

• Missing fields
• Blank fields
• Extra fields
• Malformed JSON

These correctly returned HTTP 422 responses.

The complete live flow was also tested:

Frontend
→ FastAPI
→ Ollama
→ Gemma
→ Structured JSON
→ Frontend

No application bugs were found during these tests.

Why Does Open Innovation Matter?

I chose to use an open-weight model and local inference because I wanted to be able to actually run and experiment with the AI myself.

GameDev Buddy uses Gemma 3 4B through Ollama, so the core AI workflow can run locally without requiring an external AI API key.

This also makes the AI layer relatively easy to experiment with.

The model is configurable through OLLAMA_MODEL, so the application isn't permanently tied to one model. The AI service is also separated from the rest of the application, making it easier to experiment with different local models later.

For me, that's one of the interesting things about open innovation.

It isn't just about having access to an open model. It's about being able to take that model, run it yourself, build something around it, and experiment with how it fits into your own application.

I also intentionally chose a relatively small model.

GameDev Buddy doesn't need to generate a huge game design document. It only needs to turn a few pieces of information into a short, actionable plan.

For this particular task, Gemma 3 4B was enough.

What I Learned

One of the most interesting results came from testing an intentionally over-scoped RPG idea.

The model did reduce the scope somewhat, but it still recommended systems such as crafting, quests, and city generation.

That showed me that an AI assistant doesn't automatically understand the ideal scope of a project.

Sometimes the most useful recommendation isn't another feature.

It's removing features.

That's something I would like to improve in a future version of GameDev Buddy.

My Agent Session

I used an AI coding agent during development to help implement and test the project.

I broke the development process into small steps:

• Scaffold the project
• Connect the frontend and FastAPI backend
• Integrate Ollama
• Add structured Gemma output
• Build the frontend UI
• Test realistic inputs
• Polish the documentation
• Prepare the project for submission

Breaking the work into smaller steps helped me avoid continuously expanding the scope.

The goal was to finish a small working product rather than spend the entire challenge building features that weren't necessary for the MVP.

Prize Categories

Best Use of Gemma

GameDev Buddy uses Gemma 3 4B as the core AI model.

The model runs locally through Ollama and is responsible for generating the structured development plans shown in the application.

Limitations

GameDev Buddy is intentionally an MVP.

The quality of the generated plan depends on the local model and the quality of the user's input.

The current model also doesn't always reduce oversized projects aggressively enough. In one of my tests, it still suggested several systems that would probably be too much for a beginner.

The application also doesn't have:

• User accounts
• A database
• Project history
• Persistent memory
• RAG
• A full project management system

That's intentional for this version.

The main goal is simply to help someone go from:

"I have a game idea."

to:

"I know what I should build next."

Final Thoughts

I started GameDev Buddy because a friend had a simple but real problem.

They had ideas for games, but figuring out where to start was sometimes harder than coming up with the idea itself.

So instead of building another general-purpose AI assistant, I wanted to make something focused on one specific problem.

The result is a small local AI tool that can take a game idea and turn it into a practical starting point.

It's not perfect, and there are definitely things I want to improve.

But it works, it's small enough to understand, and most importantly, it's something I could actually hand to my friend and say:

"Try this the next time you don't know what to build first."

Thanks for reading!