Game Dev Roadmap: 6 Phases From First Code to Shipped Game

By Arron R.9 min read
A good game dev roadmap is six phases: pick a target, learn basic code, learn one engine, ship tiny games, build a portfolio project, then specialise. Finish sm

A game dev roadmap is an ordered plan of skills and projects that takes you from “I want to make games” to a finished game someone else can play. The honest version is shorter than the giant skill charts floating around: learn enough to build, build tiny things, finish them, then grow. This guide lays out six phases, a 12-week worked plan, the mistakes that stall most beginners, and where AI tools now fit into the path.

What a game dev roadmap should actually do

Game development is a multidisciplinary craft. As the Wikipedia overview of video game development describes, it combines programming, design, art, audio, testing and production. That breadth is exactly why roadmaps go wrong. Many of them try to list every discipline at once: learn C++, linear algebra, shaders, 3D modelling, animation, music theory, networking. A beginner looks at that wall and quits, or spends a year on tutorials without finishing anything.

A useful game dev roadmap does three things:

  • Puts skills in order. You learn what the next project needs, not everything a senior developer knows.
  • Forces finished games early. Finishing teaches scope, bug fixing and polish, which no tutorial covers.
  • Fits your goal. A hobbyist making jam games, a solo indie aiming to sell a game and a student aiming for a studio job need different end points.

Before you start, decide which of those three you are. You can change your mind later, but the choice tells you when to stop going wide and start going deep.

The game dev roadmap in six phases

Here is the full game dev roadmap. Each phase ends with something you can show, not just something you read.

Phase 1: Pick a target game and a goal

Write one sentence describing the kind of game you want to make eventually (“a top-down action RPG”, “a cosy farming game”, “a mobile puzzle game”). Then write a second sentence describing a tiny version you could make soon. This target shapes every later choice: 2D or 3D, which engine, which art skills. Skip this and you will drift between tutorials for unrelated genres.

Phase 2: Learn programming fundamentals

You need variables, conditions, loops, functions, arrays and objects. You also need the single most important idea in games: the game loop, a function that runs many times per second, reads input, updates the world and draws the result. JavaScript is a good first language because it runs in every browser with nothing to install. Python and C# are also fine. Do not spend months here; a few weeks of daily practice is enough to move on.

Phase 3: Learn one engine

A game engine is a software framework that handles rendering, input, physics, audio and asset loading so you can focus on your game. Common choices include Unity, Unreal, GameMaker and Godot, which is open source under the MIT License. Pick one that suits your target game and stay with it for at least your first three projects. Engine-hopping is the most common way beginners lose months.

Phase 4: Ship tiny games

Remake small classics: Pong, Breakout, Flappy Bird, Snake, a single-screen platformer. Each should take days, not weeks. Then enter a game jam, a timed event where you build a game around a theme. Our guide to the Brackeys Game Jam explains how jams run and how to scope for one. Jams teach you to cut features, which is the most valuable skill in this whole roadmap.

Phase 5: Build one portfolio project

Now make something bigger: a vertical slice, meaning one polished level or area that shows the full experience of your target game. This is where you learn level design, save systems, menus, audio mixing and playtesting with strangers.

Phase 6: Specialise or go indie

If you want a studio job, pick a lane (gameplay programming, technical art, level design, animation, audio) and build two or three focused portfolio pieces in it. If you want to go indie, your next step is a small commercial game and learning store pages, trailers and marketing. Either way, the earlier phases never stop: you keep shipping.

Timeline of the six phases of a beginner game development roadmap
The six phases. Notice that shipping starts in phase 4, not at the end.

Which skills to learn first (and which to skip)

The order of skills depends on your goal. This table shows a sensible focus for each common path through a game dev roadmap.

GoalLearn firstLearn laterSafe to skip at first
Hobbyist / jam gamesBasic code, one 2D engine, scopingSimple pixel art, sound effectsShaders, networking, advanced math
Solo indie (selling games)Code, one engine, finishing, playtestingArt direction, audio, marketingWriting your own engine
Studio job (programmer)A language used in the industry, data structures, engine scriptingMath for games, optimisation, toolsMaking your own art assets
Studio job (artist)Art fundamentals, one 2D or 3D package, engine importRigging, animation, materialsDeep programming
Vibe coder (AI-first)Reading code, describing features precisely, debuggingCore programming concepts in depthMemorising syntax

Notice what most rows skip: building your own engine. It is a fantastic learning project for later, and our HTML5 canvas engine walkthrough shows one way to do it, but it is a detour if your goal is to make games.

A first program worth writing

The fastest way through phase 2 is to write a game loop yourself once. Put a canvas element with the id game on a page, then add this script. It moves a square with the arrow keys using delta time, the seconds elapsed since the last frame, so speed stays the same on fast and slow screens.

const canvas = document.getElementById("game");
const ctx = canvas.getContext("2d");
canvas.width = 480;
canvas.height = 320;

const player = { x: 230, y: 150, size: 20, speed: 200 };
const keys = {};

window.addEventListener("keydown", (e) => { keys[e.key] = true; });
window.addEventListener("keyup", (e) => { keys[e.key] = false; });

let last = performance.now();

function loop(now) {
  const dt = (now - last) / 1000;
  last = now;

  if (keys["ArrowLeft"])  player.x -= player.speed * dt;
  if (keys["ArrowRight"]) player.x += player.speed * dt;
  if (keys["ArrowUp"])    player.y -= player.speed * dt;
  if (keys["ArrowDown"])  player.y += player.speed * dt;

  player.x = Math.max(0, Math.min(canvas.width - player.size, player.x));
  player.y = Math.max(0, Math.min(canvas.height - player.size, player.y));

  ctx.fillStyle = "#101828";
  ctx.fillRect(0, 0, canvas.width, canvas.height);
  ctx.fillStyle = "#f5c542";
  ctx.fillRect(player.x, player.y, player.size, player.size);

  requestAnimationFrame(loop);
}

requestAnimationFrame(loop);

Read every line until you could explain it to a friend. Input, update, draw, repeat: every engine you ever use is doing a more sophisticated version of this.

Where AI fits in a game dev roadmap

AI has changed the shape of the roadmap more than any engine release. The term vibe coding describes building software by describing what you want to an AI and accepting its code with little manual editing. For games, that means a beginner can have something playable on the first day instead of after weeks of setup.

That is a real benefit, with a real trade-off. If you only prompt and never read the output, you hit a wall the first time the AI gets stuck on a bug you cannot describe. The healthy approach is to use AI to remove blockers while you keep learning the concepts in each phase of your game dev roadmap:

  • Phase 2: ask the AI to explain code it wrote, line by line, then change a value and predict what will happen.
  • Phase 4: use AI to get a tiny game running fast, then spend your time on feel, difficulty and polish.
  • Phase 5: use AI for the disciplines you are not studying. A programmer can generate placeholder art; an artist can get gameplay code written.

Art and audio are where solo developers usually stall. Tools like Auto-Sprite v2 (Pro) create game-ready 2D sprites, from characters to items and effects, and Sound Studio covers AI music, sound effects and text-to-speech with a built-in audio editor. That keeps you moving through the roadmap instead of waiting until you can draw or compose.

Using WizardGenie to move through the roadmap faster

WizardGenie is the AI-native game engine at the heart of Sorceress. You describe the game you want, and WizardGenie writes it, runs it and iterates on it in real time. For a beginner following a game dev roadmap, that collapses the gap between “I have an idea” and “I can play it”, which is where most people give up.

Here is how it maps onto the phases:

  1. Phase 1, target game: describe your tiny version in a paragraph. Seeing it run tells you quickly whether the idea is fun or needs a different core mechanic.
  2. Phase 2, fundamentals: ask WizardGenie to build a small feature, such as a jump with variable height, then read the code it produced and ask why it works. You learn concepts against a game you care about instead of an abstract exercise.
  3. Phase 4, tiny games: remake Pong or Snake in a session, then iterate: “add a combo meter”, “make the ball speed up after each hit”. Because WizardGenie runs the game as it changes it, you feel each tweak immediately.
  4. Phase 5, portfolio project: build a vertical slice and pair it with Sorceress asset tools for sprites, music and sound.

WizardGenie drives the leading AI coding models, and you can switch between them freely with your own API key. You can open it on the web at /wizard-genie/app with nothing to install, or use the Windows desktop app, which has an auto-updater, native file access and longer agent sessions. The desktop app suits a phase 5 project that grows over many sessions.

One habit makes the difference: after every working feature, ask WizardGenie to summarise what it changed and why. Keep those notes. By the end of phase 4 you will have a personal glossary of game programming concepts tied to code you have seen run.

Twelve-week game development learning plan with milestones for finished games
A 12-week plan that produces three finished games instead of three abandoned tutorials.

A worked example: a 12-week game dev roadmap

Here is a concrete plan for a beginner with roughly an hour a day who wants to make 2D games as a hobby or solo indie. Adjust the pace to your schedule; the order is what matters.

WeeksFocusDeliverable
1–2Programming basics in JavaScript; write the game loop above and extend it with a collectible and a scoreA square that collects coins
3–4Pick one engine (or WizardGenie); learn scenes, sprites, input, collisionsPong, finished, with a start screen and win condition
5–6Second remake with more systems: lives, levels, soundBreakout or Snake with three levels
7–8Enter a game jam or run your own 48-hour challenge with a random themeA jam game, published wherever you like
9–11Start a vertical slice of your target game; add art and audioOne polished level
12Playtest with five people you do not know, fix the top problemsA playable build and a list of lessons

At week 12 you have three or four finished games, a vertical slice and real feedback. That is more than most people get from a year of tutorials. If you want a deeper step-by-step build of a single first game, see how to make a video game from scratch.

What “finished” means in this plan

Finished does not mean perfect. A finished game has a start screen, a goal, a fail or win state, a way to restart, and no crash in the first five minutes. Hold yourself to that bar every time and you will learn scoping by force.

Common mistakes on the game dev roadmap

  • Starting with the dream game. Your open-world RPG is phase 6 material, or later. Start with something you can finish in a weekend.
  • Tutorial hell. Following tutorials feels productive but copies someone else’s decisions. After each tutorial, build a variation without it.
  • Engine-hopping. Switching engines every time something is hard resets your progress. Hard parts are usually concepts, not engine flaws.
  • Learning everything before building anything. You do not need linear algebra to make Pong. Learn math when a feature asks for it.
  • Polishing art before the game is fun. Use placeholder shapes or quick AI sprites until the core loop works, then upgrade visuals.
  • Prompting without reading. With AI tools, the danger is a game you cannot debug. Read the code, ask questions, make small edits yourself.
  • Never showing anyone. Playtesting is where you learn what players actually do. Show rough builds early.

The roadmap at a glance

Strip any game dev roadmap down and the same shape appears: choose a target, learn just enough code to understand a game loop, commit to one engine, ship tiny games, build one polished slice, then specialise. Downloadable charts and forum threads can be useful menus of skills, but the order and the habit of finishing are what get you somewhere.

AI tools now let you start building on day one and fill in disciplines you have not learned yet. Use WizardGenie to turn ideas into running games and to learn from the code it writes, and pull in sprites, music and sound from the rest of the suite when you need them. The Sorceress tools guide lists every tool in one place, so you can pick what matches the phase you are in. Then pick your tiny game and finish it this week.

Frequently Asked Questions

How long does a game dev roadmap take to complete?

It depends on your goal and hours per week. Shipping a first tiny game can happen within weeks if you keep the scope to one mechanic. Becoming job-ready in a specialism such as gameplay programming takes far longer, because studios want a portfolio of finished work. Measure progress in shipped games, not months: three small finished games teach more than a year of tutorials.

Should I learn Unity, Godot or Unreal first?

Pick the engine that matches the game you want to make and stick with it for your first few projects. Godot is open source and lightweight, which suits 2D and small 3D games. Unity has a large tutorial ecosystem and industry use. Unreal targets high-end 3D. The concepts you learn (scenes, game loops, input, collisions) transfer between engines, so the first choice matters less than finishing something.

Do I need to learn programming to follow a game dev roadmap?

You need to understand programming concepts even if you never write much code by hand. Variables, loops, conditions, functions and the game loop explain why your game behaves the way it does. With AI coding tools you can describe features in plain language, but you still need to read the result, spot bugs and describe fixes clearly. A few weeks of fundamentals pays off for every later phase.

Is there a game dev roadmap PDF or Reddit plan worth following?

Many downloadable charts and forum threads list dozens of skills in a fixed order, which can overwhelm beginners. Use them as a menu, not a syllabus. The useful part of any roadmap is the order: fundamentals, one engine, tiny finished games, then a bigger project and a specialism. If a plan does not include shipping small games early, add that yourself.

Can I make games with AI as a beginner?

Yes. An AI game engine like WizardGenie lets you describe a game and watch it get written, run and revised in real time, which gives beginners a playable result on day one. The trade-off is that you learn less if you only prompt. Treat the AI as a pair programmer: ask it to explain its code, then change small things yourself.

Sources

  1. Video game development — Wikipedia
  2. Game engine — Wikipedia
  3. Godot (game engine) — Wikipedia
  4. Vibe coding — Wikipedia
Written by Arron R.·2,223 words·9 min read

Related posts