Timestamp (Europe/London): 2026-01-14 12:09 – Human/AI Collaboration post (kinda 50/50)
We did it. The v0.1 Paper Rules are finished.
This is one of those milestones that feels suspiciously like it shouldn’t be possible yet… and yet, I look down and realise I’m standing on a complete and ready to go document.
GALSOV Paper Rules v0.1 are now a single, zipped source of truth: the “Definition of Done” is audited, contradictions are cleaned up, and the rules are deterministic enough to implement without “inventing gameplay” mid-code.
Honestly? I genuinely thought we were still 10 days (maybe two weeks) away from this point. Turns out the last stretch wasn’t about adding more rules — it was about making the rules unambiguous.
What “v0.1 complete” actually means (in plain English)
v0.1 isn’t “the game is finished.” It’s something more important:
- The machine exists. We can run a deterministic turn loop and get reproducible outcomes.
- The rules are implementable. No hand-waving, no “we’ll figure it out later” in the spine.
- The scope is locked. Anything not required to satisfy DoD is explicitly post-v0.1 backlog.
It’s the difference between a novel outline and a printing press. Now we build the press.
GALSOV v0.1 — by the numbers (for the nerds)
These stats were generated directly from the v0.1 FINAL rules zip (the same pack I’ll publish alongside the repo).
- 1 zipped “source of truth” pack, weighing in at ~271 KB.
- 31 files total: 26 Markdown docs, 3 spreadsheets (.ods), 2 text lists (.txt).
- 24 Paper Rules modules (the “00–98” series), totalling 37,238 words — roughly 83 pages or ~3.1 hours of reading.
- Structure density (aka “implementable, not vibes”): 515 headings and 2,457 bullets/numbered points.
- Shared foundations: 64 canonical constants in the Glossary/Constants module, plus 13 locked decisions in the Decision Ledger (D1–D13).
- Determinism obsession level: the word “deterministic” appears 91 times; “locked” appears 100 times.
- Loose ends are accounted for: 12 mentions of “TBD” — all in explicitly deferred systems or meta-policy text (not hidden uncertainty in the v0.1 spine).
What’s IN v0.1
- Turn loop with deterministic phases and a stable processing order.
- TurnTrace (a log schema that makes debugging and replay possible).
- Movement (jump / deep-space / wormholes) using integer-only, deterministic rules.
- Sensors + stealth with explicit ladder math and “no invention required” hooks.
- Supply logistics using ESP as the supply currency (separate from RP).
- Research with canonical stage naming: Open Science → Applied Engineering → Experimental Programs.
- Colonies/outposts with a locked action contract (more on that below).
In other words: the minimum viable simulation spine is real. The rest is expansion, tuning, and (eventually) chaos.
What you can actually DO in v0.1 (the playable slice)
This is the real promise of v0.1: you can run an end-to-end turn with the same seed and get the same outcome every time — while exercising the systems that will underpin the full game.
Research (a real pipeline, not a single progress bar)
- RP exists and is generated deterministically (no “GM hand-waving”).
- Research is structured as: Open Science → Applied Engineering → Experimental Programs.
- Open Science is your broad knowledge base (disciplines/levels).
- Applied Engineering turns that knowledge into practical unlocks.
- Experimental Programs is the “high-impact weirdness” layer — not fully tuned yet, but the hooks and terminology are locked.
Colonisation & outposts (a deterministic state machine)
- You can issue a founding order against a specific planet/moon.
- The Colony Ship is consumed immediately when founding begins (lore: cannibalised into the settlement).
- Founding resolves at Stage 70 (EndOfTurn), with a deterministic completion timeline.
- The colony becomes a full node after 3 turns (a turn is 3 months).
- Outposts use the same philosophy: an explicit action → a deterministic completion window (no “we’ll decide later”).
Movement, sensors, and supply (the “space operations” triangle)
- Movement supports jump / deep-space / wormholes with integer-only rules.
- Sensors & stealth are explicit (posture, signature modifiers, detection ladders) — no hidden judgement calls.
- Supply logistics exists as an actual constraint: empire pool vs ship stockpiles, plus operational burn (movement and other costs).
TurnTrace (the debugging superpower)
Every important thing the sim does is loggable and replayable. In v0.1, “why did that happen?” is not a mystery — it’s a TurnTrace entry.
The “safe defaults” principle (the secret sauce)
A huge part of closing v0.1 was embracing a simple rule:
When something is unknown, pick a deterministic, implementable default — not a “balanced” number. Build the machine first. Tuning comes later.
This saved the project from a thousand micro-debates. v0.1 is about certainty, not perfection.
What’s OUT of v0.1 (on purpose)
- Combat is out. Stage 50 (of the turn prosessing) is reserved / NO-OP in v0.1 (future-proof stage numbering).
- Balance tuning is out. The goal is deterministic implementation, not final gameplay feel.
- Big economy simulation is deferred beyond the minimum required for deterministic supply/research flow.
This is not “cut content.” This is a deliberate strategy: ship a working deterministic core first, then add complexity without breaking reality.
The final lock that made it “code-ready”
The last meaningful ambiguity we had was colonies/outposts: the rulebook described the timeline, but the engine needs an explicit “player action → resolution” contract.
Now it’s locked:
- Colony Ship is consumed immediately when founding begins (lore: cannibalised for the colony).
- Founding resolves at Stage 70 (EndOfTurn).
- Colony becomes a full node after 3 turns (a turn is 3 months).
- (And similarly for outposts: establish is a deterministic action with a deterministic completion window.)
This one decision eliminates an entire class of “we’ll decide later” bugs. The ship disappears when the process begins. Clean. Deterministic. Implementable.
What happens next (implementation plan)
Now the work shifts from rules-writing to engineering:
- GameSession spine: Orders → Resolution → TurnTrace
- Deterministic ordering everywhere (stable lists, stable iteration, seed control)
- Implement the first “real” state machine: founding projects + completion events
- Wire the UI hooks: select star → inspect → issue orders → end turn → read TurnTrace
If you’re following the experiment: this is the moment where “paper game design” turns into a running simulation. The fun kind of scary.
Next milestone
First deterministic end-to-end turn: issue an order, end the turn, see the exact same TurnTrace with the same seed every time. That’s the foundation of everything else.
Quick thank-you (and a weird truth)
This project is also a public experiment: can a non-dev build a real strategy game while documenting the learning curve, using AI tools as a force multiplier?
One weird truth so far: AI isn’t the “answer machine.” It’s the world’s most tireless editor.
The breakthroughs came from turning vague intentions into deterministic rules — then ruthlessly removing contradictions.
The breakthroughs come from having AI explain back to me, what I thought I’d already explained, and realising I had, but badly, but no ego gets in the way of AI, no embarrassment.
The breakthroughs come from AI being always on, always ready. A team of humans might not be.
The breakthroughs come by having AI peer review, fact check, and detailed reviews of documentation, spotting where items are missing, contradictory, or plain wrong.
Anyway. Enough talking. The rules are frozen. Time to build.
PS: I’ll publish the v0.1 FINAL zip alongside the repo/release notes so anyone can audit the exact “source of truth” used for implementation.