minting hero

Inspiration

I kept bouncing off gacha games for the same reason: you pull a character, it's bad, you reroll until it isn't. The randomness never means anything because you can always undo it. I wanted the opposite — a game where you get exactly one random hero, you can't reroll, and the fun is figuring out how this weird specific character actually works. The word "minting" stuck because the hero is issued once, like a coin, and then it's yours to live with. (No crypto anywhere in the game — it's just the metaphor.)

What it does

Minting Hero is a chunky pixel-arcade platform RPG for Windows desktop, built in Godot 4.

You pick a masculine or feminine form. Then one recorded seed assembles one hero in front of you — head, body, weapon, accessory, one boon, one flaw. No comparison screen, no reroll. You name it, and that name goes on its permanent record.

Then you actually play the thing: real side-view platform traversal (running, jumping, ledges, falls), you meet a human scout named Lira in the field and she joins you. Combat happens in the same space — no separate battle screen. You and Lira share one action-point pool (5 alone, 6 with her), and you plan a round by placing actions on consecutive numbered cost cells, then watch it play back left to right like a rhythm sequence — fully deterministic, no timing QTE. Win a fight and you apply exactly one permanent mutation to one of your hero's actions, see the before/after, and it's written into the hero's record.

Issuance is chance. Completion is choice.

How we built it

Codex was the core developer on this project — not an autocomplete, the actual implementer. Every task on the project's agent task boais owned by Codex: the deterministic hero-generation on-track combat rules, the platform field scenes, the Godot UI, the Windows export pipeline. I ran it from the CLI against the repo, wrote task contracts with explicit scope and verification commands, and reviewed what came back.

GPT-5.6 did the thinking work around the code: the design documents (player experience architecture, the M1 scene wireflow, the production-stage contract), art direction for the pixel-arcade look, and adversarial review passes on Codex's output before anything got committed. The stack: Godot 4.7.1 (GDScript), pinned project-locained. The architecture keeps a pure deterministicdomain layer (hero generation, AP rules, action-track legality, mutation) with zero scene/node dependencies, so all the game rules run headless under test. An earlier Phaser + TypeScript prototype survives only as a deterministic regression oracle that the Godot rules are checked against.

Challenges we ran into

The biggest one wasn't code — it was that AI agents cthings that don't run. Early on I shipped a milestonethat looked finished in the summary and fell apart the moment I actually played it. The fix was process: I wrote a fail-closed production gate (a PowerShell script the agents must pass) that separates "the tests pass" from "a packaged build of this exact commit was actually played." Documentation, screenshots, and green tests can't promote the project's stage — only a human playing the build can.

The second was engine migration: the first prototype was Phaser in the browser, and pivoting to native Godot desktop meant re-proving every combat rule. Keeping the old prototype alive as a fixed-seed regression oracle is what made that migration checkable instead of vibes-based.

Also, Windows MAX_PATH broke the packaged-build artifact tree. That was a fun afternoon.

Accomplishments that we're proud of

The whole loop is connected in one packaged Windows build: title → story → form choice → one irreversible seeded mint → naming → platform field → Lira recruitment (and you can see the AP pool grow from 5 to 6) → same-field battle on the numbered action track → one permanent action mutation → hero record → back to the field, with nothing unloaded in between.

I'm also proud of the discipline artifacts: a pure domain layer that runs headless, a cross-engine regression oracle, and an agent task board where every change has an owner, a scope, and a verification command. That's what made "Codex as core developer" actually work instead of drifting.

What we learned

Treat AI agents like contractors, not oracles. The productive setup was narrow task contracts, explicit verification commands, and a gate that fails closed — after that, Codex's output qleneck.

Determinism is a superpower for AI-built games: because every rule is seed-driven and pure, both the agents and I could prove behavior with fixtures instead of arguing about what "should" happen.

And design-wise: removing the reroll is the entire game. Every time I was tempted to add candidate comparison or rarity feeds, the game got worse on paper. One hero, no undo, is the point.

What's next for minting hero

A 15–20 minute vertical slice: a miniboss, the hero's boon/flaw traits actually interpreted by story callbacks, full save/restore, and representative art and audio to replace the graybox lter that — the AP formula (min(8, 5 + companions)) isalready built for it. Same rule as always: nothing ships until a human plays the packaged build and says it's real.

Built With

• codex
• gdscript
• godot
• gpt-5.6
• json
• node.js
• phaser.js
• powershell
• typescript
• vite
• windows-11