How I got better physics by removing the rules

I built a piece of software to run combat for a homebrew tabletop RPG. It had a command-pattern core like a little terminal, a damage calculator that prompted you for every field with toggles for how much complexity you wanted, an inventory and data layer that could equip items to characters and apply their modifiers, and persistence that saved configs back and forth between a JSON store and a SQL database. It was, by any reasonable standard, overengineered. You could type attack A B C D or attack A group_b and it would resolve the whole thing in one shot.

Then I ran it at a live table for the first time, and it was awful.

Not buggy-awful. The math was right. The damage it produced was realistic — a defensible number falling out of a defensible formula. And typing the inputs in was fast; that part took maybe ten seconds. The problem was subtler and worse than slowness: the entire turn disappeared into a prompt. I'd ask for inputs, the box would chew on them, and a number would come back out, and during all of that the five people at the table heard nothing. There was no swing of the sword, no scramble, no fiction — just me looking at a screen and then announcing a result they had no way to see coming. The turn wasn't slow. The turn was dead.

That distinction turned out to be the whole game. A thirty-second turn where someone is talking the entire time — describing, reacting, deciding out loud — beats a ten-second turn where you punch a number into a calculator and everyone waits for an obscure result to drop. "Fast" was never really about the clock. It was about never going dead, and the engine made the table go dead on every single turn, no matter how quick the typing was.

So the engine wasn't the answer. Worse, it was a red herring — something that looked like the answer the entire time I was building it, and only revealed itself as a symptom once I watched it run. The actual fixes turned out to be smaller numbers and a layer I had been treating as decoration. This is the story of how I got from there to a system that resolves a turn out loud, in the fiction, and feels more physically real than the simulator did, mostly by deleting things.

§ 01The seven things I wanted, and why they fight

Before any of this, I had written down what the system was supposed to be. Seven properties:

1. Fast — I wrote "ten-second turns" at the time, but the real target, which I only understood later, is never dead. A turn should never stall into silence while someone computes; the action should keep moving and keep being heard.
2. Physically accurate — you should be able to put out a fire with water because of how the system works, not because the GM allows it. Attacking at range should be less accurate than point-blank. Getting stabbed should often be enough to end a fight.
3. Balanced — no single master build; every build has a counter.
4. Open — within the rules, a player should be able to try anything and get a sensible result.
5. Universal — no separate math for players and enemies, no separate damage equations, no special cases. One ruleset, the way the natural world has one ruleset.¹
6. Fun — built on the belief that people are most creative inside strict constraints, so the rules should help players discover things rather than wall them off.
7. Simple at the table — no flipping to a wiki to look up a single number and then suffering decision paralysis anyway.

The thing about these seven is that they are mostly at war with each other.

Physical accuracy wants more rules — range modifiers, footing, lighting, material interactions, the works. Simple-at-the-table and fast want fewer. Balanced wants the designer to be able to tune outcomes; open wants the system to never secretly punish a weird choice to enforce that balance. Universal wants one equation for everything; physical accuracy wants the equation to be rich enough to model everything, which is how equations get long.

You can satisfy any three or four of these at once. The whole project was the tension between satisfying all seven.

§ 02Why V1 reached for a simulator

Faced with "physically accurate," the obvious move — the move that felt right at the time — was to simulate the physics. Compute it. If you want a stab to do a believable amount of damage that depends on who's stabbing and who's being stabbed, you write a damage function. So I did.

A quick orientation, because the rest of this leans on four stats and two resources. Characters have PHY (physical strength and durability), FIN (finesse — dexterity, accuracy, evasion, and physical charisma), COG (cognitive — mental capability, understanding, language, persuasion, mental charisma, and counters), and MGK (magic). They have HP (health) and SP (the pool spells are paid from). V1 spelled the mental stat COM and split magic into three sub-budgets — capacity, output, recharge — but the four families are the throughline across both versions, so I'll use the V2 names.

Four is not an arbitrary count. It's the most I could compress D&D's seven stats down to without losing anything I cared about — another simplicity cut — and it lands one notch above three, the bare minimum for a rock-paper-scissors.²

V1 ran on continuous numbers. Stats were a 50-point buy across PHY, FIN, and COM, plus that separate magic budget. HP started around 100 and climbed past 290 by the level cap. Mana pool, per-turn channel cap, and regen all came off square-root curves, which meant lookup tables for every derived stat at every level. A hit resolved through an accuracy-versus-evasion comparison that produced a scaling factor, and damage was that scaling times a weighted sum of your physical and magical output.³

It is genuinely not a bad model. If you sit down and audit it, the numbers behave. A glancing hit chips you; a clean hit hurts; a big attacker hits harder than a small one. It is physically accurate in the literal sense I had asked for.

It is also completely impossible to run in your head. The full chain looked like this:

$\text{ACC} = \text{FIN}_\text{mod} + d20 + \text{wpn} - \tfrac{\text{dist}}{10} \qquad \text{EVA} = 5 + \text{FIN}_\text{mod} + \Delta\text{Level}$

$\text{scaling} = \frac{\max(\text{ACC} - \text{EVA}, 0) + c}{20} \qquad \text{damage} = \big(2.5\,\text{PHY} + 2.0\,\text{OUT}\big)\times \text{scaling}$

You cannot evaluate that at conversational speed, multiply through, and track a three-digit HP pool for six combatants, while also being a fun GM. So the math demanded an engine. The engine wasn't a feature I chose to add. It was the consequence of choosing numeric simulation as the road to physical accuracy. The moment you decide physics means computation, you have signed up to build a computer, or to be one.

And here is the part that took the live run to see: a model that's accurate and unrunnable has quietly failed at five of the other six goals to satisfy one of them. It is not fast. It is not simple at the table. It strains "fun" because turns drag. It barely helps "open," because the player can't predict what the black box will spit out, so they can't reason about clever plays before attempting them — and a system you can't reason inside of isn't really open, it's just permissive.

§ 03The oneshot, and the exact shape of the disappointment

So I ran it. Real players, the V1 bestiary, the whole apparatus.

The diagnosis that came out of that session is the most useful sentence in this entire piece: the combat was realistic and unsatisfying. Those two words don't usually sit together, and when they do, it's damning. "Unsatisfying" alone would suggest I needed better numbers. "Realistic and unsatisfying" means the numbers were fine and the realism itself wasn't landing — that the thing I'd built the engine to deliver was being delivered and nobody could feel it, because it arrived as a silent, opaque number with no texture.

I didn't even make it through the session before figuring this out. We were still inside the first encounter of three when I quietly stopped consulting the calculator and just started making up damage numbers out of thin air — a reasonable value, a little variance, called on the spot. The table immediately liked it more. The fight got faster, but more importantly it got louder: I was narrating instead of typing, the numbers came with a description attached, and the players had something to react to. The most over-engineered part of my own system, abandoned live, mid-fight, in favor of me guessing — and the guessing was better. That should have been mortifying. It was actually the best data I got all night.

That reframed the problem. I had assumed "more accurate" was upstream of "more satisfying." It isn't. You can have all the accuracy in the world and produce a dead table. The realism that players actually feel at a tabletop has very little to do with whether the damage number is defensible and almost everything to do with whether the fiction is responsive — whether the world reacts to what you did in a way you can see, hear, and predict.

A TTRPG is not Baldur's Gate. Nobody at the table is tracking exact distances on a grid to the foot; the spatial reasoning is already loose and verbal. Spending enormous machinery to compute a precise output on top of inputs that were always approximate is a category error. I was bringing a SQL database to a campfire.

§ 04The two moves that actually mattered

Everything good about the current system comes from two decisions. Not seven, not the elaborate perk economy I'll mention later — two.

Move one: make the numbers tiny. This was non-negotiable and it came first, because it's the only thing that lets resolution happen out loud instead of in a box. In the current system, base HP is 3.⁴ A standard major hit — stabbed, shot, hit by lightning — does 1 damage. Damage is hard-capped at 3 per hit, and the only thing that breaks that cap is fighting something well above your weight class. The entire derived layer collapses to two lines you can do in your head:

$\text{mod} = \left\lfloor \tfrac{\text{stat}}{2} \right\rfloor - 5 \qquad (\text{so a stat of } 1\text{–}20 \text{ maps to a modifier of } -5 \text{ to } +5)$

$\text{Accuracy} = d20 + \text{FIN}_\text{mod} \qquad \text{Evasion} = 7 + \text{FIN}_\text{mod}$

That's the whole combat resolution. Roll, add a small modifier, compare to a number near 7. You can hold an entire character in your head: a few HP, a few SP, four modifiers, a handful of perks. There is nothing to look up and nothing that needs a calculator, which means the GM can resolve a hit while narrating it rather than disappearing into a prompt. The small numbers don't buy speed on the clock so much as they buy the ability to never go dead.

But small numbers, on their own, would give you a thin, bloodless game. If a stab is just "lose 1 of your 3," where did the physics go? Where's the fire that water puts out? Where's the lost finger?

Move two: make narrative a mechanic. This is the load-bearing one, and I want to be honest about what it is: it's a duct-tape job. Small numbers tore a hole in physical accuracy, and narrative is the patch I jammed into the hole. It is not elegant. It is the best part of the system.

The idea is that the GM's narration isn't flavor sitting on top of the mechanics — it is a mechanic, with the same binding force as a damage number. Take a real example. One of your players loses their right index finger. No system can enumerate every possible injury to every possible body part; the combinatorics are infinite and writing them down is exactly the bloat I was trying to escape. But the physics of it are obvious to any human at the table: if you're an archer and you lose your draw-hand index finger, your arrows are going to bias low, and that's roughly the whole consequence — you can still handle the bow, you're just off. A machine cannot generate that ruling. A GM does it without thinking. So you let them, and you treat what they say as real.

This is the move that makes "universal" and "open" survive the budget cut. The mechanical layer stays universal and tiny — same damage, same can-or-can't-draw-the-bow, one ruleset for everyone. The un-enumerable layer — the narrative consequence of the un-enumerable event — gets handed to the one general-purpose reasoning engine already at the table. Same input, roughly the same output. The catch is that in a living game the input is never quite the same twice, and that's precisely the part you can't and shouldn't try to compute. So you give it back to the GM, whose single greatest weapon was always narration anyway.

What this looks like versus the alternatives

The cleanest way to see the difference is to put the same moment through three systems. Take one exchange — a specific hit, a specific lost limb, the same two combatants — and resolve it three ways.

An unstable mining cave. A swordsman and a wizard, neither with room to maneuver. The swordsman closes in and cuts across the wizard's sword arm. The wizard counterattacks.

In D&D 5e, the fighter closes the gap and brings the longsword across the wizard's arm. Fourteen on the die, plus six, against fourteen armor — it lands. Eight points; she has seventeen of twenty-five left.

"You slash across her forearm," the GM says, and marks the number down.

The wizard steps back a few feet and raises the catalyst. Same roll, same modifier, against sixteen armor — that lands too. Eleven points of fire. He has thirty-one of forty-two.

The forearm is not a factor. The cave is not a factor. The mine's instability hasn't been assigned a rule, so it cannot apply. The fight will resolve through hit points, and when one of them runs out, it will be over.

In Kirimana V1, the fighter closes to five feet. The engine prompts for inputs — the table goes quiet. A fourteen on the die feeds into accuracy 16.5 against evasion 3; scaling 0.85; forty-seven damage. She has 73 of 120 hit points.

"The blade opens her forearm badly," the GM says. Forty-seven points come off her sheet. The forearm is in the description.

She fires back — thirty mana, point-blank. Thirteen on the die; accuracy 11.5 against evasion 8; twenty-five damage. His sleeve catches fire: five chip damage per turn from here.

The wizard retreats around the nearest bend. Her forearm doesn't come up again — the formula doesn't know about it, so she casts at full accuracy from deeper in the mine. The chip damage climbs. The fighter loses five a turn to the burning sleeve and takes hits besides, while the wound the GM narrated three turns ago has no entry in the system. The numbers close before he reaches her.

In Kirimana V2, the cave gives neither of them room. The fighter is inside the wizard's reach before she can create distance, sword already moving across the arm — the forearm, the muscle that works the wrist.

The GM calls it before the dice have settled: "That arm works. It won't aim. Disadvantage on spells until she treats it."

Fourteen on the die, plus two, against evasion six — hit, one damage. Three hit points left.

The wizard tries to fire back. With disadvantage she needs a nine. She comes up with two. The bolt misses — but the cave wall behind the fighter doesn't. The blast takes a seam of loose shale with it.

The GM looks at the table for half a second. Unstable mine, fire in an enclosed space, a ceiling that was already suspect: the rock comes down in that section. The exit is gone.

The air was already thin. With the fire still burning and the passage sealed, it gets thinner. "Third turn," the GM says, "oxygen poisoning starts."

The wizard has three hit points, a compromised arm, and no way out. The fighter will outlast her. He will not outlast the cave.

In D&D, narrative is cosmetic. You lose the arm in the fiction, the rules don't know, and next round you're swinging the two-handed weapon anyway because no number on the sheet changed. The story and the mechanics are divorced; the injury is a sticker.

In Kirimana V1, narrative is conditional. The GM describes the wound, and the system even tracks the fire that catches on the fighter's sleeve — because fire has a formula. But the gash on her forearm disappears. The formula consumed the body part and returned a number, and the story can't call it back.

In Kirimana V2, narrative is the mechanic. The arm is gone, so you can't draw the bow, or your shots bias, and that ruling carries the exact weight a damage number would. It isn't flavor on top of the math. It's doing the math's job.

The point of the comparison is that "realistic" and "the rules model it" are not the same thing. D&D's severed arm is more rules and less realism. V2's is less rules and more realism, because the realism lives in a place rules were never going to reach.

§ 05The tier system is what made small numbers survivable

There's a hole in "make the numbers tiny" that I have to close, because it's the obvious objection: if everyone generally has between 4 and 6 HP and a decorated hero deals 1 damage on most hits just like a peasant would, what does getting stronger even mean? If raw numbers don't separate people, the system collapses into noise.

The answer I stole — and I mean stole; I read all of Will Wight's Cradle between V1 and V2 and lifted the realm ladder more or less wholesale⁵ — is a tier system. Seven tiers, from Unbound at the bottom (children, isolated populations who barely interact with the rules) up through Forged, Awakened, Reforged, Exalted, Ascended, and Atua at the top (beings who destabilize the world just by existing).

The tier, not the stat line, becomes the power axis.⁶ Within a tier, everyone is roughly comparable, so you don't need fine-grained numbers to separate a "level 13" from a "level 12" — that distinction, which is what forced V1's giant lookup tables, simply stops needing to exist. What separates two same-tier combatants is perks and play, not arithmetic. What separates different tiers is tiergapping, which allows the same one damage number to operate on completely different levels. The tier absorbs the entire job that V1's scaling formulas were doing, which is how you get to delete the formulas. And like D&D handing you a feat or a proficiency every few levels, each tier-up grants something concrete — a perk, an HP or SP bump — so progression still has shiny moments; they're just discrete and few instead of a continuous drip.

And tiers do something the continuous ladder never did: they make fights at different altitudes qualitatively different rather than just numerically bigger. Two Forged fighting is a different game from two Awakened — not because the numbers are flashier, though they are, but because the kind of thing each can do has changed. The clearest engine of that difference is embodiment, which begins at the Awakened tier: a character comes into an elemental attribute and slowly grows into it.⁷ It starts faint enough to barely matter, then deepens as they move through the tier — they get more in tune with it, and it gets more of a grip on them, picking up extra strengths and weaknesses as it goes. Crucially, the element isn't a damage type you pick off a menu; it's an expression of who the character turns out to be. Two people with a wind attribute can be nothing alike: wind-as-storm and wind-as-something-gentle are different characters, and the divergence shows even on the body — the marks the element leaves, called an attunement, take different shapes and feel different from person to person. That divergence is the tier's story — figuring out the self, and watching the world write the answer onto the skin. (Continuous levels gave you "the same fight, larger." Tiers give you genuinely different games stacked on one chassis.)

All seven tiers are playable — but the very top generally isn't worth existing at for too long. The world itself goes soft up there — beings that destabilize reality by existing don't leave you much solid ground to set an encounter on. So most campaigns, by design, live between tiers two and four, or sit almost entirely in tier three, and the world's promotion requirements are structured to keep them there. Tier one is the other special case: it's meant to play like a horror game, with no turn system at all, because you barely interact with the rules — the intended mode is the players listing actions as fast as they can while the GM fights back in real time. It's the one place the system stops being a system, and it only became possible once the math was small enough to run combat at conversation speed. You can't improvise real-time combat while computing a scaling factor.

§ 06How the war ended

With the two moves and the tier system in place, the seven properties mostly stopped fighting — not because I negotiated a truce between them, but because most of them turned out to be downstream of the same decisions.

• Fast and simple at the table fall directly out of small numbers. There's nothing to look up.
• Balanced stopped being something I tune and became something the structure enforces. When damage is capped and HP is tiny, you cannot stat-stack your way into a master build — raw numbers don't scale far enough to matter. Differentiation gets pushed into perks, positioning, and the counter game, where there are real answers to everything. A counter specialist gets kited; a bruiser gets pelted from outside their range; whoever controls the range band controls the fight, and a sustained positioning advantage is worth more than any stat. No build dominates because the cap won't let it.
• Universal got cleaner, not messier. One modifier formula, one accuracy-versus-evasion rule, one tier ladder for heroes and monsters alike. The single deliberate asymmetry in the whole system — tiergapping — is also the single exception to the damage cap. One legible violation of universality instead of a hundred hidden ones.
• Open and fun ride on narrative-as-mechanic plus the tier spell catalogs. Players can try anything, and the GM can rule on it instantly because the mechanical surface is so small that almost everything resolves to "make a roll, deal about 1, and here's what happens in the fiction."

There's a third axis under all of this that I don't want to undersell: perks. If small numbers and the tier system answer how strong are you, perks answer the more interesting question — what kind of strong? That question is the entire reason perks exist, and designing them is real architecture, not decoration. You should be able to read the FIN perk list alone and see the dimensions it spans: vertical mobility, horizontal mobility, burst movement, technical finesse (locks, sleight of hand), and — yes — simply looking dapper, because charisma lives there too. A character isn't defined by their stat line; they're defined by which slice of that space they bought into. The balance work here is significant and ongoing.

What is genuinely secondary is the numeric tuning around the perks — exactly where the point gates sit, how many perks a stat band unlocks, the precise value of a modifier. Those numbers don't mean much next to which perks exist and which a player picks, though they still pull real mechanical weight. (Stats themselves end up feeling less like a source of bonuses and more like gates — thresholds that unlock perks — with the actual modifier riding along as a minor rider. It's better to optimize toward clearing a perk band than toward nudging a modifier up, which quietly inverts the instinct D&D drills into you, where you chase the +1.⁸)

§ 07The engine was a red herring

Here's the thing I most want a younger version of me to hear.

The engine was a real piece of software. Command pattern, dual persistence, group-targeting, the works. I was proud of it, and by some measures it was the most "engineered" thing in the project. And it was pointed at the wrong problem the entire time.

It looked like the answer because it was an answer to the question I'd asked — "how do I compute realistic combat?" The engine computed realistic combat beautifully. The trap was that the question was wrong, and a sufficiently good answer to a wrong question is more dangerous than a bad one, because it doesn't fail loudly enough to make you re-ask. The engine didn't crash. It produced correct, defensible, realistic, unsatisfying numbers in dead silence, and the very competence of it kept me from noticing that simulation was never going to get me what I wanted.

What killed it wasn't a better engine. It was redefining "physically accurate" from numeric fidelity to qualitative predictability — from "the damage number is defensible" to "water beats fire, a stab is usually one clean point, and you can see all of this coming before you act." That version of physics needs no computer. It needs small numbers and a human. The moment I made that swap, the engine didn't get improved or replaced. The problem it solved evaporated, and it had nothing left to do.

I'm fairly sure I could not have arrived here without building it first. It is deeply counterintuitive that you get better physics by removing rules rather than adding them, and that automation can make a thing slower and worse. You don't believe that from an argument. You believe it after you build the automated, rule-heavy version, run it in front of five people, and watch it die.⁹

§ 08The bill: this system runs on the GM

Every system has a failure mode, and I'd be doing the same dishonest thing the engine did if I pretended this one doesn't.

V1's failure mode was "realistic and unsatisfying, plus long turns." V2's failure mode is GM-dependence. The system deliberately doesn't catch you the way the math did. All the load I lifted off the players and the table — the un-enumerable physics, the narrative consequence, the range adjudication — landed on the GM. A great, well-prepped GM makes it sing. A mediocre or under-prepared one gets soft chaos, because the safety rail of "the engine will tell you the number" is gone on purpose.

I know this because I was the under-prepared GM. The first V2 session went substantially better than the V1 oneshot, but we'd scheduled on short notice and I hadn't prepped enough, and you could feel where the system leans on prep that wasn't there. Players also felt a little too much freedom with the open magic early on — the fix there is probably a starter spellbook as an on-ramp,¹⁰ everyone on rails to begin with and free to step off as they learn, rather than dropping a newcomer straight into open improvisation. And what I most wished I'd had was a catalog of environments and creatures to pull from on the fly. My ideal was that GM prep would be minimal; what I learned is that prep can only be minimal if there's a deep, fast-to-search library standing behind it.

Which is the funny part. The engine already had a file system — directory navigation, a cd command in the TUI, the works. What it didn't have, and what I actually need, is the difference between cd and zoxide: not the ability to walk a tree by hand, but fast, fuzzy, get-me-there-instantly retrieval over a deep library of scenarios, creatures, environments, and rulings. The engine solved the problem I didn't have — computing outcomes — and gave me only the most primitive version of the one I do have, which is finding the right content fast. If software comes back into this project, that's the shape it'll take: less calculator, more search index, and it will have learned its lesson about what to compute and what to leave to the human.

§ 09Receipts: the system says no in the right places

Speed you can demo in one turn. The harder claims — every build has a counter, advancement is earned narratively and not bought, the open system doesn't collapse into a single best move — only show up across a whole character's arc, and the only honest way to test them is to watch characters develop and see where the system resists. So I ran a long design exercise: a collaborator invented characters and storylines freely, with no knowledge of the underlying mechanics, and I played only the system's side — embodiment, tiers, matchups, what advanced and what stalled.¹¹ Three of those runs are worth compressing here, because each one proves a different claim by failing to advance on demand.

Irel, water, who halted. Irel started as a river-delta kid whose magic mostly meant clean drinking water and a dull knife swung in a panic. He grew into a support fighter — splashes to interrupt, a weighted net to set up allies — and then he stuck. He couldn't reach Reforged, and the system wouldn't let him, because his embodiment was at war with itself: water as softness and healing versus water as pressure and consequence, and he was mediocre at both because he'd committed to neither. He only advanced once he decided what water meant to him — boundary, the pressure between us and them, calm depths fringed with rough surf, an attunement that made children wary of him. And then he halted again, permanently, at Reforged: he never reached Exalted because he never had the will to claim the larger role it demands. That's the whole point. Advancement isn't a number you accumulate; it's a question you answer, and a player who won't answer it stays where they are no matter how many fights they win.

Bren, wind, who got beaten at his own game. Bren was a deliberately awkward build — wind affinity welded to a two-handed warhammer, the opposite of the agile skirmisher wind is "supposed" to be. He made it work by reinterpreting the element: not wind-as-freedom but wind-as-commitment, the principle that once motion starts, resisting it gets expensive. He became a regional fixture, a man who held a bridge so reliably the world planned around him. Then another Reforged crushed him at that bridge by matching commitment with more commitment, earlier and closer, stopping his acceleration before it could become inevitable. The bespoke build had a clean counter, exactly as promised. What's better is what the loss did: cornered and seconds from death, Bren turned the hammer down into the bridge and dropped the whole span out from under both of them, surviving by biasing his own fall — and walked away with a deeper reading of his own element. The counter didn't invalidate him. It taught him commitment had to include the fallback, not just the charge.

Sael, crystal, who had to give something up. Sael was the player-brained escalator — crystal affinity plus a domination interaction, a blacksmith's maul as casting focus, a habit of self-experimentation that ran to replacing their own blood with flowing crystal. Their embodiment became cascading innovation, and it carried them all the way to Exalted on the strength of building tools that could answer almost anything. But Ascension wouldn't come from more of the same. It required a sacrifice that cut against the character's entire identity: to ascend, Sael had to collapse possibility itself, rewriting their embodiment so that every act resolves fully or never begins — surrendering the improvisational, mid-fight experimentation that was the most them thing about them. The tier above mortal excellence doesn't cost more power. It costs the thing you'd least like to pay.

None of these arcs were scripted toward these lessons; they fell out of playing the system straight against characters it had never seen. That's the receipt I actually care about — not that the system produced cool characters, but that it told three different players no in three different, correct ways, and each no was the thing that made the character mean something.¹²

§ 10The actual lesson

The portable lesson is not "delete your code," and it's not "tabletop games should be rules-light." It's narrower and more useful than either.

It's that a sufficiently good solution to the wrong problem is the hardest kind of mistake to catch, because competence masks the misframing. The engine worked. The good-code definition I've written about elsewhere → holds here too — good code is code that saves time — and the engine saved no one any time; it took a number a human could call out in one breath and routed it through a silent prompt instead, spending the table's attention, which is the most expensive resource in the room. And it rhymes with what I learned debugging infrastructure with an AI that was confidently, fluently wrong →: the machine collapses the cost of doing the work, but deciding which work is worth doing — which small, checkable, human-shaped piece actually matters — stays the job. The engine was automation that looked like progress. The durable skill was noticing it wasn't, and being willing to throw away the most impressive thing I'd built.

I wanted physical accuracy and I reached for a physics engine, which is the obvious move and the wrong one. The accuracy players can actually feel turned out to cost almost no numbers at all — three HP, one die, a hard cap, and a human being trusted to say what happens when you lose a finger.

The world is called Kirimana. It's a place built out of Rules that even its creator is subject to. It took me an entire engine to learn that the Rules should be few, and that the most important one is to know which parts of the world you were never supposed to compute.