No Plan Survives First Contact: Building a Game From Scratch

Everybody loves to say game dev is "iterative." Sounds clean, right? Nice little spiral climbing up toward a finished thing, everybody holding hands. Here's what it actually is. You plan hard, you plan early, you do everything right — and then first contact blows half of it to pieces anyway. Because no plan survives first contact. Not in a firefight, not in EVE, not when you're building a world from nothing.

The real loop isn't a spiral. It's a fight between the decisions you made last month and the ones you're making right now. Here's what that actually looks like in the dirt.

It starts with a vibe, not a design doc

Nobody starts with a 200-page bible. You start with a feeling you can't shake and two or three games living rent-free in your head. A salt-corroded coast. The knife-edge of full-loot PvP. The way one game absolutely nailed its territory war and then fumbled everything around it.

Your first job isn't to design. It's to pin down what you're chasing tight enough to actually build toward it. Sounds easy. It's not. "Post-apocalyptic" is a vibe — a direction with no distance, useless on its own. "Steam-dominant survivor world where the rare cyber-tech is salvaged relics, and the apocalypse was a bomb that tripped the grid" — that's something you can actually move on. The difference between those two sentences is a dozen decisions, and every one slams some doors shut and kicks others open.

You'll get it partly wrong. Good. The premise is a starting read, not a contract.

Every system you build is a wall you now have to fight around

This is the part nobody warns you about, so listen up. Every system you lock in isn't just a feature. It's a constraint you just handed future-you. You build a gem system that runs on free-form stats — no Strength, no Intelligence, none of that. Cool. You didn't just build a gem system. You made a promise to every system you haven't written yet.

Then two months later somebody goes "hey what if Perception buffed your shooting?" And that "little idea" just walked straight into a wall you poured yourself. The idea isn't even bad. But it can't just get bolted on. It's gotta be reconciled. Either the wall moves or the idea reshapes to fit. That grind, that friction where the new thing scrapes against the old thing? That's not the system breaking. That's intel. It's your own game telling you something true about itself. Most people flinch from that friction. Don't. Lean into it.

And here's the discipline that keeps you alive: write the decision down, and write down why. A decision with no reason attached is a landmine you buried for yourself. Six weeks out you'll be standing on "no attributes" with zero memory of why you called it, and you'll either follow it blind or blow it up. Both wrong, both because you didn't leave yourself a note. Self-inflicted, and completely avoidable.

The cycle — four moves, no romance

Strip the pretty talk off it and the loop is four moves.

1. Build the actual thing. Take it from vibe to spec — the real spec, the one a coder could build off. "It has gems" is not built. That's just hand-waving. "Gems roll three words, each word maps to a stat, a curse-word bumps another word up a tier, here's all 500 entries in a table," that's built. Concrete or it doesn't count.
2. Break it on purpose. Throw it at the rest of the design and watch where it cracks. Does your shiny new combat loop assume a death-and-loot rule you never wrote? Did the faction count you just changed orphan seven lore docs? The break is not the failure. The break is the whole point. You want to find the crack now, on paper, cheap. Not in month eight when it's load-bearing and the whole thing comes down on your head.
3. Reconcile, and make it stronger. This is the craft right here. Most contradictions aren't "pick A or B." They're "find the angle where both are true." Real example: a bomb apocalypse smashed into an existing cult whose entire religion was built on a single breaker tripping. Easy move is delete the cult. Wrong move. The fix: the bomb's blast tripped the breaker. Now the cult worships a click and never knows a warhead caused it, and the story is better than it was before the collision. Reconcile it right and you don't subtract. You go deeper.
4. Let it hand you the next job. Every reconcile coughs up the next gap. Define death-and-loot, now you need to know how dungeons handle invaders. Decide dungeons get invaded, now you need a population cap so it's a real fight and not one squad steamrolling a lone player. Each answer hands you the next question. That's why the work never ends, in the good way. The game tells you what it needs next. You just have to listen.

When you've got too much, consolidate — don't delete

You're gonna hit the wall where there's just too much. Seven factions, forty systems, a map screaming for five biomes. Your gut says delete, and deleting hurts. Feels like you're tossing work in the fire.

There's a better move: consolidate. Seven factions collapse into three banners, but the seven don't die. They become wings and orders under the three. The debt-collectors, the salvagers, the road-traders, all still there, now three wings of one outlaw coalition. You kept every hour of worldbuilding and you got a cleaner three-way war out of it, which is better for PvP anyway. Two-way fights stalemate; the stronger side just snowballs. Three-way never sits still — there's always a third party to swing the fight.

The lesson travels. When you've got too much, hunt for the bucket that turns your excess into structure before you reach for the delete key. Most "too much" is really just "not organized yet."

Protect the irreversible. Stay loose on everything else

Not every decision is the same weight, and treating them like they are will freeze you solid. Some calls are cheap to reverse — a number, a name, a little UI flourish. Flag those as working calls and move. You're tuning them in playtest anyway. A title can stay a working title right up until the day you announce. Don't bleed over it.

Other calls are the foundation, and ripping them out later costs you everything. The security model. Whether the server or the client runs the show. The shape of your economy. Those get real thought up front, and once you've called it, you defend it. When you decide the client is just a dumb renderer and every real decision lives server-side, that's not a preference. That's the spine the whole anti-cheat and IP story hangs off of. A random meeting note does not get to knock that over.

Knowing which kind of decision you're staring at — cheap-and-reversible or foundation-and-load-bearing — that's most of what "good judgment" even means in this work. Skill can be taught. That judgment is hard to find.

Build the world so the world builds itself

The highest-leverage systems are the ones that spit out more game than you put in. A handful of hand-placed anchors — spots a quest can point at, NPCs a story can grab — let a generator stitch together endless quests out of finite, hand-built parts. A procedural loot table turns a few hundred words into a chase that never runs dry. A behavior tracker plus a tight trait pool lets a character grow an earned identity you never once scripted.

The pattern under all of it: build the parts and the rules, not the instances. You don't hand-write a thousand quests. You write the pieces a thousand quests get built from, and the guardrails that keep them from turning to garbage. That's how a small crew ships something that feels massive. But hear me on this. It only works if you did the earlier steps clean, because a generator amplifies whatever foundation it's standing on. Contradictions included. Build on sand, it'll mass-produce sand.

What it actually feels like

Some days you write a system you're genuinely proud of. Some days the whole session is just you finding out that the thing you shipped last week quietly broke the thing you shipped last month, and the work is nothing but untangling the mess. Both days are the job. The untangling days don't feel like progress, but that's where the game actually gets good. That's where a loose pile of cool ideas turns into one thing that holds together under its own weight.

Building a game from scratch is not a clean march from empty to done. It's a long argument with your own past decisions, and the win isn't dodging the contradictions — it's resolving them so the whole comes out stronger than it went in.

The spiral metaphor sells it short. It's less like climbing a ladder and more like running a long op. You set the plan, first contact wrecks half of it, you adapt, you push, and if you stay honest about what's actually working, the thing slowly stops being a pile of systems and starts being a world.

Then you spot the next gap, and you reset and go again. And that part — the reset, the next contact, the next problem? That's not the boring stretch before the fun.

That is the fun.

No plan survives first contact. Build anyway.