What do you think of this tactic in indie game dev ? For one of the first games: - At…
- User
What do you think of this tactic in indie game dev ? For one of the first games:
- At first, focus on the essential, the underlying system on which the game run have to work, even if the player don't really see that system.
- Then, focus on making all mechanics of the game in a relatively functionning state, everything have to be done, even if it's half working or if they are very clunky.
- Implement the bare minimum at first, for examples for the 50 monsters, each with their animations and attacks, let's them have biting and tail swipe, for all of them at first.
- The idea is to make a functionning game as fast as possible, even if it's crap.
- Then fix, develop, upgrade, render more complex and so on every parts that were implemented.
- Keep for the last the most difficult ones, so the experience gained from the easier parts translate to make the harder parts easier than if done directly.
- Develop everything as modules, that can be added, replaced or removed easilly.
- visual assets come last, just have the bare minimum at first, with half baked animations too, these can be fixed later.
- Assistant
Your idea is basically the “get-the-whole-thing-working-first, polish-later” style of development.
That’s a totally viable way to ship a game, but there are a few pitfalls that devs hit over and over. Below is a quick breakdown of the strengths, the watch-outs, and a couple tweaks that make the strategy safer.
1. Why this CAN work
🟢 Fast feedback.
You get something running quickly and can playtest the game, not just isolated systems.🟢 Agile / MVP mindset.
If the core loop isn’t fun, you find out sooner and can pivot without having sunk months into art and fancy shaders.🟢 Modularity.
Designing features as plug-ins forces you to create clean APIs, which pays off later for DLC, modding, porting, etc.
2. Common traps
Trap Why it hurts How to dodge it “We’ll clean it up later” debt Sloppy code & placeholder data accumulate. Eventually refactors are so painful that you don’t do them. Schedule code-cleanup days every sprint. Ship each feature at least “B-quality” before moving on. Hard problems left for last The “unknown unknown” might break your engine or design late in the project. Spike the riskiest tech FIRST (networking, streaming, etc). You don’t need final code; just prove it’s feasible. Everybody testing totally un-polished builds Pure gray boxes sap morale and give unusable user-testing feedback (“it just feels off”). Sprinkle in a little juice early—temporary SFX, hit-flashes, screen-shake—so the game feels alive. Horizontal slice overload Building 50 half-working monsters is costly and clutters your bug list. Build one or two complete monsters, prove the pipeline, then mass-produce. Marketing material deficit You need GIFs, screenshots, press kits months before launch. Plan vertical-slice milestones where one level/room looks close to final for trailers.
3. A battle-tested hybrid: Fast vertical slice
-
Week 0-2: Paper & engine spikes
• Quick prototypes of risky tech.
• Decide camera, controls, core loop. -
Month 1: Graybox vertical slice
• One level, one enemy, one boss.
• Temp art, but final timing, feel, enemy AI loops.
• Focus play-testing here until “this 5-minute chunk is fun.” -
Month 2-n: Production in modules
• Combat module, inventory module, save/load module, etc.
• Every module ships at “beta quality” before next one starts.
• Content factory: designers/artists crank out enemies, areas, quests using the proven pipeline. -
Final months: Polish & performance
• Replace temps with final art.
• Optimize, bug-bash, accessibility pass.
• Marketing assets, demo, Steam page, wish-list push.
4. Quick answers to each of your bullets
• “Underlying system first” – 👍 yes, but prototype risky systems early.
• “All mechanics half-working” – Fine, but spike hard parts sooner, and don’t spread yourself across 50 placeholders; aim for depth before breadth.
• “Bare minimum for enemies” – Start with one enemy skeleton that supports all required actions; after that the 49 variations are mostly data.
• “Make a functioning game ASAP even if it’s crap” – Good, but give it a minimum ‘fun layer’ (simple VFX, SFX) so play-tests are meaningful.
• “Fix/upgrade later” – Schedule time for this or it never happens.
• “Hard parts last” – Actually: hardest tech spikes first, hardest content last.
• “Everything modular” – 100% agree. Plan interfaces early, document them.
• “Visual assets come last” – Final art, yes. But some visual juice should come early for feedback & morale.
5. TL;DR
The tactic works if you:
- Prototype the riskiest stuff first.
- Build one fun, polished vertical slice early.
- Keep tech debt under control with regular clean-ups.
- Add just enough art/juice early to test feel and market the game.
Follow those guardrails and the “crappy-build-first” approach becomes a fast, lean path to shipping an indie game instead of a swamp of half-finished features. Good luck, and have fun! 🎮
-
- User
I'm talking to two LLMs at once, one of you said:
- "Actually: hardest tech spikes first, hardest content last.", and "The 'unknown unknown' might break your engine or design late in the project. Spike the riskiest tech FIRST (networking, streaming, etc). You don’t need final code; just prove it’s feasible.", and it's actually part of the "underlying system", if the game is a multiplayer one, having the multiplayer part work is the first thing to do, even if it's the absolute hardest. The "underlying system" could have been named "the very core of the game" too, if you take minecraft, it could be it's world generation, if you take shadow of the mordor it may be it's genesis system, if you take a 4X, it may be the AI and the resource system.
- "Building 50 half-working monsters is costly and clutters your bug list.", and if it's 500 monsters to make it even more extrem for my argument, split in 5-10 skeletons, each with just these animations: idle, walk, bite, tail swipe, ( and dead position if no ragdoll), with each monsters with each skeleton having one shared model, with at most a swap color or some fast details/trinkets to differentiate them (a crest, spikes, bulbs, frills, ect.), those will be done very fast at first, and if there's no eating animation yet, don't matter, it can be added later, and even if they are unique monsters, they would share some animations too, just look at the kut ku compared to the rathalos in monster hunter, both have the same skeleton, and uses some common animations, with only on top their specific ones. And for the "demo" or when working on implementing the fighting with more than "bite + tail attack", you may create a model for one monster to really test it.
- Assistant
Totally hear you.
Let me re-state your two clarifications and then offer some practical do’s / don’ts:
CLARIFICATION #1
“Underlying system” = all mission-critical, high-risk tech (multiplayer stack, procedural world-gen, large-scale AI, etc.).
→ Yes, that should be proven FIRST, even if it is the scariest work.CLARIFICATION #2
For 500 monsters you’d mass-produce them via 5-10 shared skeletons + a couple of generic anim sets (idle / walk / bite / tail swipe / death) and palette-swap or add minor geo to differentiate.
→ Reasonable, as long as the pipeline is solid and the final game still feels varied.Now, some field notes from teams that tried exactly this:
-
Spike the riskiest TECH, not the riskiest CONTENT ────────────────────────────────────────────────── • Multiplayer, deterministic rollback, world-streaming, huge AI grids—those can up-end the whole project.
• Build “ugly proof-of-concept” scenes for each; measure perf, net-roundtrip, memory, save/load integrity, etc.
• Once a tech spike is green-lit, you can safely move on to content factories (monsters, levels, quests). -
Set up an ASSET PIPELINE immediately ─────────────────────────────────────── Steps that pay for themselves when you go from 10 → 500 creatures:
Concept ⟶ Base Mesh ⟶ Rigging/Retarget ⟶ Variant Generator ⟶ In-Game Prefab
• Script the boring bits (texture bake, LOD gen, prefab naming).
• Keep a single “gold” skeleton per family; use engine retargeting for everything else.
• Put animation events (hit frames, VFX hooks) on the skeleton once; all children inherit them.
• Store per-variant data (HP, size, special attacks) in data tables / ScriptableObjects so designers can tweak without touching code.- Beware of “Fake Variety”
───────────────────────────
Players will spot a reskin in seconds if:
• Attack timing is identical.
• Roars/screams are pitch-shifted clones.
• AI behavior = same circle-strafe + bite loop.
Cheap ways to add perceived uniqueness: • Param-driven animation curves (slower lumbering ogre vs snappy raptor).
• Different hit FX / sound libraries per family.
• One signature move or gimmick per monster tier (even if re-using existing bones: e.g., a “burrow” that hides mesh and plays dust VFX).-
Keep the BUG LIST SANE ───────────────────────── Creating 500 half-working prefabs can drown QA.
• Lock a family of monsters only when its base skeleton + core states are bug-free.
• Then stamp out the 50 color swaps—those should introduce zero NEW bugs.
• Tag placeholders clearly (“_TEMP”, “_WIP”) so you can mass-query and purge them before alpha. -
Milestone Plan (example) ──────────────────────────
M0 – Tech spikes prove multiplayer + procedural generation run at 60 fps on min spec. M1 – One skeleton fully rigged, anim’d, in-game, fun to fight (incl. audio/VFX). M2 – Pipeline automated; 10 variants generated, QA passes.
M3 – All skeleton families completed at “beta quality”.
M4+ – Content explosion to 500 creatures while design & audio add personality. -
Memory / Perf Reality Check ────────────────────────────── 500 prefab instances can hammer: • Animation memory (each retarget adds overhead).
• Navmesh & AI update time.
• Draw-call limits if materials aren’t batched properly.
Test a “stress arena” early: spawn 200 different monsters at once and profile FPS, RAM, network bandwidth.
TL;DR
• Absolutely prove the hard tech first—that’s the real “core”.
• Mass-producing enemies via shared skeletons is fine; just industrialize the pipeline so QA and performance stay under control.
• Inject small bursts of real variety (AI quirks, sounds, one signature attack) so the army of palette-swapped biters still feels fresh.Do that, and your “make it work first, then make it good” strategy scales without turning into a spaghetti monster of its own. Good luck! 🐉🛠️
-
- User
LLM1 said "Creating 500 half-working prefabs can drown QA.", so why not create one prefab that change based on data instead ? The data could contain the mesh path, which base animation set to use, it's specific animations, the AI modules to use and some other datas and voila, no ? Basically have one big object type (here "Monster"), and one big "XML" (or other type of database) to contain all the different datas to initialize those objects.
- Assistant
“Just one Monster prefab + a giant data table” is a perfectly valid, very common pattern— but like everything in game dev it comes with trade-offs.
Below is a quick breakdown of WHY you’d do it, WHEN it bites you, and a HYBRID approach that gives you the best of both worlds.
WHY A SINGLE-PREFAB + DATA-DRIVEN APPROACH ROCKS
-
Centralised bug-fixing
• Change health-bar anchor once → every monster inherits the fix.
• Animation-event timing tweak? Touch a single Animator Controller. -
Lean QA on structure
• QA tests one prefab for state-machine errors, hit-detection, rag-doll, etc.
• Variants merely change data, so they can be smoke-tested instead of full regression. -
Ultra-fast content iteration
• Designers drop a new row in Google Sheets / CSV / JSON, hit “Reload Data,” and a 501st monster appears. No engineers needed. -
Runtime flexibility
• Live‐ops balance passes, holiday skins, or event bosses can be shipped as a content patch—no code change / no app-store re-submission.
SOME GOTCHAS TO WATCH FOR
Area Potential Pain Mitigation “Big-bang” breakage One bad commit in the shared prefab can break EVERY monster. Branch discipline, prefab versioning, CI test that instantiates every row. Designer ergonomics Scrolling through a 500-line XML is ugly; non-tech designers hate copy-pasting GUIDs & paths. Build a small in-editor UI (Unity custom inspector / Unreal Blutility) to pick assets via dropdowns. Asset bundle size If each variant references unique meshes & materials, you still have 500 asset dependencies that must be downloaded. Group variants into bundles by biome / chapter so players stream what they need. Memory / hot-swap Loading every mesh just to seed a dropdown menu can explode editor RAM. Lazy load asset references; keep only paths/IDs in the table, load mesh on demand. Network replication The client must know what “MonsterID 437” means. Ship the same data table to client & server; validate hash on connect. Testing the data You will still miss typos (“TailSwip” vs “TailSwipe”). Schema validation + unit test that tries to spawn all rows on headless build.
WHAT “ONE PREFAB + DATA” LOOKS LIKE (Unity-ish Example)
Monster.prefab
• Components: Animator, Ragdoll, AudioSource, MonsterController.cs
• Scripts expect a MonsterDefinition object at runtime// MonsterDefinitions.json (could also be ScriptableObjects) [ { "id": 101, "name": "Emerald Drake", "meshPath": "Assets/Meshes/Drake_Emerald.fbx", "skeletonID": "DragonHumanoid", "animSet": "DragonBasic", "hp": 3500, "aiModules": ["FlyHover", "FireBreath", "TailSwipe"], "lootTable": "DrakeCommon" }, { "id": 102, "name": "Crimson Drake", "meshPath": "Assets/Meshes/Drake_Crimson.fbx", "skeletonID": "DragonHumanoid", "animSet": "DragonBasic", "hp": 5000, "aiModules": ["FlyHover", "InfernoCone", "TailSwipe"], "lootTable": "DrakeRare" } ]MonsterFactory.cs
public GameObject SpawnMonster(int monsterID, Vector3 pos) { var def = MonsterDB.Get(monsterID); // Lookup JSON / ScriptableObject var go = Instantiate(_monsterPrefab, pos, rot); // One prefab for all // Load & assign mesh var mesh = Addressables.LoadAssetAsync<Mesh>(def.meshPath).WaitForCompletion(); go.GetComponentInChildren<SkinnedMeshRenderer>().sharedMesh = mesh; // Animation override _animator.ApplyOverride(def.animSet); // Inject stats & AI var stats = go.GetComponent<MonsterStats>(); stats.MaxHP = def.hp; var brain = go.GetComponent<AIController>(); brain.LoadModules(def.aiModules); return go; }
A HYBRID THAT MOST LARGE TEAMS END UP WITH
- Base prefab (MonsterBase) – holds universal systems (locomotion, hit reactions).
- Family prefabs (DragonBase, GolemBase…) – only when skeleton or locomotion style changes drastically.
- Variant data rows – hundreds of colour swaps / stat tweaks on top of those families.
This way: • A change to biped locomotion doesn’t risk quadruped dragons.
• QA matrix = 5–10 families × critical edge-cases, not 500 “unique” objects.
• You still get spreadsheet-driven production speed.
QA STRATEGY WITH DATA-ONLY VARIANTS
Automated • Unit test: iterate through every row, spawn, run 5-second animation loop, assert no null refs / missing clips.
• Stress test: spawn 200 random IDs, profile FPS & memory on min-spec hardware.Manual • Create a “variant gallery” level that teleports the tester to each monster in order; allow one-button pass/fail tagging that writes back to a CSV.
• Focus manual QA on “family exemplars” and any row that differs by more than N% from the base stats (extreme HP, giant scale, etc.).
TAKE-AWAY
• One-prefab-plus-data is excellent for speed and consistency—do it!
• Guard against the single‐point-of-failure problem with small family prefabs, schema validation, and CI tests.
• Invest a day or two in editor tooling so designers aren’t crying over raw XML.That setup gives you the scalability you’re after without turning your QA team (or your Git history) into a smouldering crater. Happy monster farming! 🐲📊
-
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.