The clock a newborn was born on was the wrong one
When a creature is born in The Long Watch, the world writes down the exact moment it arrived. That stamp is the spine of a whole life — everything that later asks “how old is this animal?” measures the gap from then to now. We got that stamp wrong, in a way that is almost embarrassing to describe, and the strongest safety net we own watched it happen without flinching.
The number was right. It was just written in the wrong unit. And the reason that slipped through is the whole point of this note, because it exposes a blind spot that no amount of careful testing closes — it’s structural, baked into what a particular kind of check can and cannot see.
The world keeps two clocks
The Long Watch runs on two beats at once. There is a fast heartbeat — sixty ticks a second — for everything you watch happen moment to moment: a creature stepping toward food, the small motions of a living world. And there is a slower, calmer beat, a handful of ticks a second, for the big background processes that play out over in-game days — a body breaking down into the soil, and reproduction.
A birth is a slow, day-scale event, so it lives on the slow beat, kept off the busy fast loop. That split is deliberate and good. It only became a trap at the one seam where the two clocks meet: the moment a newborn is stamped with the time it was born.
Right number, wrong unit
Here is the mistake, in plain terms. The birth event runs on the slow clock, so the code stamped each newborn with the slow clock’s count. But every part of the world that later reads a birth time — aging, the slow creep of frailty, the day-to-day arithmetic of a life — expects that number to be in the fast clock’s units. So the stamp was a real, stable, correct number. It just meant something entirely different to the thing that wrote it than to everything that read it.
The fast heartbeat ticks about twelve times for every beat of the slow one. So a newborn’s age, computed from a birth time written on the wrong clock, came out roughly twelvefold too large. A baby was treated as if it were about a dozen times older than it really was — aging, maturing, and growing frail almost the instant it arrived. By the numbers, the very first creatures born into the world were old men at birth.
The fix itself was small and surgical: stamp each birth with the fast-clock equivalent of the slow beat it actually happened on. The care was in how that conversion is computed. It uses only fixed configuration — the known, constant relationship between the two clocks — never anything that depends on frame timing or how fast a given machine happens to run. That detail isn’t fussiness; it’s load-bearing. A birth time that drifted with frame rate would make the same world age differently on a slow laptop than on a fast desktop, and two players handed the same seed would no longer be watching the same world. Anchoring every birth to a value derived purely from game-time is what keeps every machine’s world identical.
The net that couldn’t see it
Now the unnerving part. Our strongest safety net is a check that proves a world replays identically: start from the same conditions, run the simulation, and you must get the same world back, down to the byte. It is the spine of how we trust a saved world, and we lean on it harder than anything else we’ve built. We trust it so much that the question worth sitting with is why it sailed straight past a bug this large.
Because that net only ever watches for one thing: does the same input produce the same output, every single time? It is a test of sameness. And the bad birth time was perfectly, beautifully stable. It was the wrong number with the wrong meaning — but it was wrong the exact same way on every run, from the same seed, on every machine. A value that is wrong but deterministically wrong is invisible to a determinism check, because there is nothing for it to disagree with. It reproduces the bug faithfully, forever, and reports green.
A determinism gate can tell you a world is the same every time. It cannot tell you the world is right. Those are two different questions, and only one of them was being asked.
This is not a check that was misconfigured, or filed wrong, or blind because we’d switched an input off. It was working exactly as designed and verifying exactly what it claims to. The gap isn’t a defect in the check; it’s the edge of what this kind of check can witness at all. A green replay proves byte-stability. It says nothing about whether the bytes mean what you think they mean.
So how did we catch it? Not with a sharper test — with arithmetic. Before building the next piece on top of the birth time, we re-derived the units by hand from the source of truth: what beat does a birth run on, what does the stamp record, and what units does the reader expect? The two didn’t match, and the dozenfold gap fell straight out of the multiplication. The bug was caught by a person re-checking the math at a boundary, which is the only thing that ever could have caught it.
Two guards, not one
The real repair wasn’t the one-line conversion. It was admitting that we’d been asking a single check to answer two questions it could only answer one of. So alongside re-locking the reproducibility net — confirming the corrected world still replays byte-for-byte — we added a separate, dedicated guard that checks the units directly: that a newborn’s recorded age, right after birth, is what the arithmetic says it should be, in the units the readers expect.
That second guard would have screamed on day one. The first one never could have, and asking it to was the actual error. A reproducibility check and a correctness check are different instruments measuring different things; conflating them is how a wrong-but-stable value hides in plain sight behind a wall of green.
The discipline that came out of it
The lesson generalised, and it cost us again before it fully sank in: the same two-clock confusion later resurfaced at a different seam — in the path that lets scavengers feed on a fallen body — and was fixed the same way. Two appearances of one mistake was enough to turn it into a standing habit.
The habit is this: re-derive your time arithmetic from the source of truth at every seam between pieces of work. Wherever one part of the system writes a number and another part reads it — especially a number measured in ticks, where two clocks can quietly disagree about what a tick is — don’t inherit the assumption that the units line up. Check it. Multiply it through. The cost is a minute of arithmetic; the alternative is a deterministic gate that will reproduce your bug perfectly, every run, on every machine, without ever once telling you it’s there.
The births themselves work — a creature can finally have young, and that milestone is its own story. This one is only about the small, quiet number underneath it: the clock a newborn was born on. Get that stamp right, in the right units, and a number becomes a life you can follow from its first day. Get it wrong but stable, and the one check you trust most will hand you back a perfect, green, twelvefold lie.
