How I Built a SEGA Genesis Tribute Game with Copilot Cowork and ChatGPT

Vibe-coding a 1990 roguelike into existence — no IDE, no build step, just two AI tools and a weekend.

1. How I Built a SEGA Genesis Tribute Game with Copilot Cowork and ChatGPT
   1. The Idea
   2. The Workflow
   3. Setting the Stage
   4. The Sprites: AI as Pixel Artist
   5. The Music: ChatGPT for Audio
   6. The Systems Cowork Built Without Me Typing Code
   7. The Bugs and How Cowork Fixed Them
      1. Equipped weapons disappear from my inventory.
      2. The bread icon looks like a goblin.
      3. Black screen after Load Game.
      4. My character faces left when I walk right.
   8. What It Felt Like
   9. The Final Result
   10. Download The Game

The Idea

I’ve been wanting to build a tribute to Fatal Labyrinth — that brutal little 1990 SEGA Genesis roguelike where you crawl 30 floors of a dungeon to retrieve the Holy Goblet from the Ancient Dragon. Hunger meter, perma-death, the works.

Normally a project like this means setting up a repo, picking a framework, sourcing pixel art, hunting down royalty-free chiptune music.

This time I tried something different: I used Copilot Cowork for the code and ChatGPT for the art and music.

I didn’t open a code editor once.

This is the story of how that went.

The Workflow

The loop was simple and absurdly fast:

• I’d describe what I wanted in plain English to Copilot Cowork.
• Cowork wrote the code directly into the HTML file.
• When I needed art, I’d ask Cowork to write me a prompt for ChatGPT.
• I’d paste the prompt into ChatGPT, get a sprite sheet back, drop it in the workspace.
• Cowork wired the new sprite into the game.
• I’d refresh the browser and play.

That was it.

No commits. No PRs. No waiting on builds.

Cowork even handled the file I/O — it could see my uploads, modify the HTML, and post-process images when needed.

Setting the Stage

I started with a one-liner to Copilot Cowork:

Build me a roguelike inspired by Fatal Labyrinth as a single HTML file.
Canvas 2D, no framework.

Cowork spun up the scaffolding: a 60×22 tile map, room-and-corridor procgen, field-of-view raycasting, turn-based monster AI, an inventory, a hunger meter, and level-up curves.

All in one file.

It even tracked which features it had done and what was next.

Within the first session I had a playable prototype — ASCII tiles, but the systems were already there.

The Sprites: AI as Pixel Artist

ASCII is fine, but I wanted the SEGA feel. I wanted real characters and items, not ASCII.

I asked Cowork which Sprites we should use for the game, it gave me a nice starting point.

This is good but I want it to have actual sprites.
I can generate and upload just tell me what you need

Next I asked Copilot Cowork to write a ChatGPT image prompt for the tile sheet.

Give me a prompt i can give to GPT images v2 to generate these.

It came back with something like:

Create a single sprite sheet for a 16-bit Sega Genesis-era dungeon crawler.
Layout: 6 columns × 4 rows grid of equal-sized square cells, solid pure black (#000000) background,
no borders or gridlines drawn between cells, no text, no labels, no captions, no numbers anywhere.
Each cell contains exactly ONE centered sprite.
Consistent pixel-art style across all 24 sprites:
bold readable silhouettes, vibrant saturated colors, dark outlines, limited palette, top-down or slight 3/4 perspective, no drop shadows extending beyond the cell.
Sprites in reading order (left to right, top to bottom):
Row 1:
(1) gray cobblestone dungeon floor tile,
(2) gray stone dungeon wall block,
(3) descending stone stairway viewed from above,
(4) glowing golden Holy Goblet chalice with gems,
(5) heroic human adventurer in chainmail wielding a sword, facing forward,
(6) iron longsword
Row 2:
(1) iron chestplate armor,
(2) red healing potion in glass bottle with cork,
(3) rolled parchment scroll with red ribbon,
(4) loaf of brown bread,
(5) pile of gold coins,
(6) brown sewer rat 
Row 3:
(1) brown bat with spread wings,
(2) small green kobold with crude club,
(3) green goblin with dagger and leather vest,
(4) muscular gray orc with battle axe,
(5) white skeleton warrior with rusty sword,
(6) huge green troll with wooden club
Row 4:
(1) ghostly purple hooded wraith,
(2) massive brown ogre with spiked club,
(3) red horned demon with claws,
(4) skeletal lich in dark robes holding glowing staff,
(5) bull-headed minotaur with double-bladed axe,
(6) black-armored death knight with greatsword and red eyes
Style: clean pixel art, 16-bit Sega Genesis aesthetic, vibrant colors,
strong outlines, pure black background only — absolutely no text,
letters, words, or numbers in the image.

ChatGPT generated it.

I uploaded it, Cowork wrote a sprite-slicing helper, and suddenly the dungeon had monsters with personality.

We did the same for:

• A weapons sheet — 24 individual weapons across a 6×4 grid
• A player walking sheet — 4 directions × 4 walk frames
• Five weapon-baked character sheets — the player holding a sword, axe, mace, flail, and club
• An effects sheet — slashes, fire bursts, smoke, sparks, heals, and teleports
• The Ancient Dragon — 4×4 with idle, roar, fire-breath, and hurt rows

Each one followed the same pattern:

1. Write me a ChatGPT prompt for X.
2. Get the prompt.
3. Paste it into ChatGPT.
4. Upload the result.
5. Cowork wires it in.

The dragon was the most fun.

I asked Cowork where the existing boss sprite came from — it admitted it had just been scaling up the demon sprite 2× with a red glow.

Lazy.

So I had it write a prompt for a real dragon with animation rows. ChatGPT delivered a gorgeous result.

Prompt it gave:

A 16-bit SEGA Genesis-era pixel art sprite sheet of a massive
ancient dragon boss, viewed from a top-down 3/4 perspective.
Arrange it as a clean 4-row by 4-column grid on a fully transparent
background, each cell exactly 256×256 pixels (total image 1024×1024).
The dragon should be hulking, intimidating,
drake-shaped with leathery wings folded back,
jagged spines along the spine, glowing red-orange eyes,
smoke curling from its nostrils, and dark crimson-purple scales
with ember-glow undertones. Keep all four cells in a row the same pose
seen from the same angle, with only animation frames differing.
Row 1 (top) — IDLE BREATHING, facing camera (front view):
4 frames of the dragon's chest rising and falling,
wings shifting slightly, smoke puffing from nostrils.
Row 2 — ROAR / ATTACK, facing camera: 4 frames of the dragon rearing
back, jaws opening wide, claws raised. Frame 1 wind-up, frame 4 full roar with bared fangs.
Row 3 — FIRE BREATH, facing camera: 4 frames of the dragon exhaling flam
downward. Frame 1 inhale glow in throat, frames 2-4 streaming fire
from open mouth.
Row 4 (bottom) — HURT / FLINCH, facing camera: 4 frames of the
dragon recoiling from a hit, body twisting, one wing flaring defensively,
eyes wincing.
Style requirements: chunky pixels, hard outlines, limited 16-bit palette
(deep crimson, oxblood, ember orange, charcoal, gold highlights),
strong contrast, no anti-aliasing, no gradients, no soft shadows,
no blur. Same pixel-art rendering style as classic Sega Genesis
dungeon crawlers like Fatal Labyrinth or Shining in the Darkness.
Cells must be perfectly aligned to the 256-pixel grid with even spacing.
Transparent (alpha) background — not white, not black.

One problem: the export had baked a light-gray checkerboard into the background instead of using actual transparency.

Cowork wrote a quick Python script with PIL to detect the near-grayscale light pixels and convert them to alpha-zero. 43% of pixels became transparent.

The dragon now drops cleanly onto any palette.

The Music: ChatGPT for Audio

I asked ChatGPT to give me a prompt for Suno.ai which is what I would usually use for AI Music. But ChatGPT suggested it could create a beat that matches the game. So I said YES, and it generated a 30-second WAV.
(NOTE: I had no idea this was possible!)

I uploaded it, and Cowork:

• Added an audio loop with preload enabled
• Wired up a toggle button in the corner
• Persisted the on/off preference in localStorage
• Handled browser autoplay rejection silently

The music only starts after the user clicks a difficulty button, which counts as legitimate user interaction for autoplay.

The preference survives reloads.

All from one request.

The Systems Cowork Built Without Me Typing Code

Here’s a non-exhaustive list of features I described in English and got working in minutes:

• Procedural floor generation — rooms, corridors, stairs, monster and item spawning by depth
• Turn-based combat with damage rolls
• Hunger system — drains per turn, starvation at zero, regen when fed
• Field-of-view raycasting with persistent “seen but not visible” tiles
• Smooth tile-to-tile movement interpolation — 140ms ease-in-out, lunge on attack
• Floating damage numbers and a hit-flash overlay
• A visual effects system — slashes, blood, fire, smoke, sparkles, level-up rings
• Six SEGA-style per-zone color palettes with tinting
• Difficulty system — five orthogonal multipliers across four tiers
• Save/load to localStorage — including the tricky bit about preserving equipped-item references via inventory indices
• A 30-floor boss arena with teleport mechanics, ranged fire breath, and pillar cover
• HP and hunger bars in the sidebar with low-state pulsing

Every one of these came from a sentence or two.

Cowork would also keep a running task list visible to me — I could see what was done, what was next, and what was in-progress without nagging.

The Bugs and How Cowork Fixed Them

I caught a few issues during playtesting. My 5 year old son also found some bugs.

The cycle was always the same: I’d describe what was happening, Cowork would diagnose it, edit the file, and I’d refresh.

Equipped weapons disappear from my inventory.

It was splicing the weapon out of the array on equip. Cowork rewrote it to store a reference and mark the slot with [E].

The bread icon looks like a goblin.

A sprite atlas off-by-four-pixel bug. The HUD icons were using the wrong scaled cell size. Fixed in two lines.

Black screen after Load Game.

The game loop was being started inside the new game branch of the difficulty picker. Continue bypassed it. Cowork hoisted the animation frame call out of the callback.

My character faces left when I walk right.

The player sprite sheet had its rows in a different order than the code assumed. Two-line swap.

Each fix took roughly one round trip.

No stack traces. No console diving.

Just:

This is broken (See image)

What It Felt Like

The interesting thing wasn’t any one feature.

It was the velocity.

I was iterating on a game design in real time — not because the code was easy, but because I never had to write the code.

I described intent. Cowork translated it. ChatGPT generated the assets.

I stayed in the creative loop the whole time.

A few things stood out:

• Cowork preserved context across the entire session. It knew the project layout, the conventions, and the systems it had built. I didn’t have to re-explain anything.
• The “write me a prompt for ChatGPT” pattern is gold. Cowork knew exactly what sprite-sheet layout it needed and could ask ChatGPT for it in the right format.
• Post-processing AI output is a real workflow. The dragon checkerboard background and the music wiring would have been blockers without a tool that can actually run code on the assets.
• A dev console added at the end paid for itself ten times over. Floor jump, item spawn, kill-all, reveal-map. I should have asked for it on day one.

The Final Result

One HTML file.

About 1,500 lines.

Six sprite sheets.

One music file.

No build step. No dependencies. No tooling.

Drop it in a folder, open it in a browser, click Normal, and the labyrinth claims another soul.

I didn’t write a single line of code.

I designed a game.

Built with Copilot Cowork and ChatGPT, over a few hours, with a healthy respect for 1990.

Download The Game

Want to try this game yourself? Here is the full Zip folder.
Just extract it, and open the HTML file.

Cowork-Game-fatal-labyrinth-V2.zip