Two Python datetimes, an hour apart, and == says they're equal:
datetime(2026, 11, 1, 1, 30, tzinfo=ZoneInfo("America/New_York")) with fold=0 and fold=1.
US clocks go back tomorrow, so 1:30am happens twice. Same-zone comparisons ignore fold. Convert to UTC first.
We ported Newsroom from Python to Go, but didn't rewrite lxml's HTML parsing.
We compiled libxml2 2.14.6 and libiconv to WebAssembly and run it inside Go with wazero, with the module's sha256 pinned.
Same C parser, same output.
My Chinese text passed every test and still had three characters the font didn't have.
Glassvow bundles cut-down (subset) Noto Serif TC fonts to keep the game small. A new privacy notice used 凍, 協 and 問. None were in the subsets.
A CI check that reads every translated string and compares it with the font caught it. The fix was to reword the line. The check now covers 1,182 characters.
If you subset a font, add that check. Bookmark this for your next translation pass.
Glassvow Devlog #6
The game sent more than its Settings screen said. So I fixed the words, and cut what it sends.
The toggle read "Send Crash Diagnostics". It also sent errors and freezes. Now it reads "Send Diagnostics", and the notice says crash, error and freeze.
Two cuts went in with it:
- no installation ID on events
- no breadcrumbs (the trail of recent log lines)
What I can't claim yet: the iOS native layer may still send its own session data. That needs an SDK rebuild and a check on a real device.
Follow along if you want the unfinished parts too.
When you port a library to another language, the dangerous answer is "close enough". In Newsroom's Python-to-Go port, the JSON Schema validator supports only the draft 2020-12 subset we use and returns Unsupported for anything else. PyYAML loads a self-referencing alias; our Go loader refuses it, and the divergence is written down.
Getting one Go test suite green on both Linux CI and a Mac taught us two things this week.
First: a test checked what happens on a non-blocking connect to a full unix-socket queue. Linux returns EAGAIN. macOS refuses with ECONNREFUSED (and has no SOCK_CLOEXEC, so vet stopped first). The test was right, just Linux-only. It now lives in a _linux_test.go file.
Small Godot export tip if your game has big paintings.
21 of the scene and stage paintings in Glassvow went over our 4 MiB cap for a single texture upload.
We didn't shrink or recompress the art. At export, a plugin swaps each of those paintings for a generated resource holding two lossless pages, each at most 3,151,872 bytes. The original PNG path still loads, and the game gets the full-resolution picture. The source art in the repo is untouched.
Then CI exports a real pack and audits it: all 21 paintings, all 42 pages, exact pixels. It also feeds the audit packs we break on purpose, to prove it can say no.
Fix the pipeline, not the painting.
The planted defects are the part worth copying.
A check you've never watched fail is a guess. Porting our news product from Python to Go, we moved a parser limit from 1,024 to 1,023 on purpose to see if the tests noticed. 4 boundary cases failed, which is what we wanted.
We may have been looking for AGI in the wrong place.
Over the past few days, I built something inside Grok Bot that changed how I see AI.
It started as a video editor. It is now an organization of more than 30 AI agents.
There is a director, a producer, researchers, video editors, 3D artists, fact checkers, and quality control. Some agents exist only to monitor and improve the others.
They delegate work, challenge each other’s decisions, and run entire production pipelines. They can call Claude, GPT, Gemini, DeepSeek, Grok, Blender, and dozens of other tools.
All of them share a second brain. It is a structured library in the cloud holding footage, research, scripts, tools, decisions, and every past project.
Footage from an old project can become part of a new one. A mistake one agent catches becomes a lesson for all of them, and a fix becomes a tool any of them can reuse.
The organization never starts from zero. It accumulates.
What got me was asking the system how to make itself better.
It audited its own architecture and listed its weaknesses. It consulted competing models, wrote new tools, and rewrote the rules it runs under.
One audit found quality checks the system believed were running that had never actually executed. It built replacements, planted defects on purpose, and measured whether the new checks caught what the old ones missed.
When a frontier model’s advice contradicted the system’s own test results, it went with the evidence. Every fix went into the second brain, so each project started out better than the last.
Somewhere in there, I stopped feeling like I was using an AI. I was overseeing a team of them.
We have spent years picturing AGI as a single mind that can do everything.
Human civilization got smart a different way. No one person ever knew how to do it all. Millions of specialists learned to coordinate, and writing let what they discovered outlive the people who discovered it.
The intelligence lived in the organization.
I am not claiming my system is AGI. Watching it work just made one possibility hard to ignore.
AGI might show up the same way human intelligence did, as an organization.
A flaky test taught me not to take Postgres join order for granted.
It checks that stored embeddings are fresh, so it should count exactly 1 model call. On Linux CI it sometimes counted 21.
Same query every time. The planner had just picked a different join order.
A layout bug you can only see by eye comes back. One you measure stays fixed.
On our card game's event screen, the test doesn't compare screenshots. It builds every event under a live run HUD, dressed like a real run, and reads the rectangles the player sees:
- the event title clears the top bar, the seats and the relic row
- the choices clear every HUD element
- on the phone, both choices of every two-choice event are fully visible
11 events, each as a choice and as a result. Phone, pad and desktop. English and Traditional Chinese. 2,376 rectangles.
The quiet trick is the worst case. The pad test carries 13 relics, because a test with 3 relics would pass forever.
And what it doesn't prove: our automated capture never reached an event screen in the cloud, and no real phone was checked for this change. That rides the next test build.
Bookmark it for the next time you touch your HUD.
Glassvow Devlog #5
Our first fix for a wrapping title on the phone made it fit on one line. It also turned "The Rootheart" into "THE ROOTHE…".
One line, as asked. But the player had lost where they were.
So the merged fix shrinks the place name from 14 px down to 10 px first, and only trims if it still doesn't fit. A test now checks every screen shape, both languages and every act: 0 of 24 combinations clip.
Shrink before you trim.
Glassvow Devlog #4
For a while our Godot CI had a script check that could never fail.
It ran godot --headless --check-only -s on every script and stopped on a non-zero exit code. But on Godot 4.7.1, check-only prints the parse error to stderr and still exits 0. We tried a duplicate declaration, an unterminated string, a type mismatch and warnings-as-errors. Exit 0 every time.
So in August we rewrote it. The check now reads stderr for script errors and checks the exit code separately, for crashes.
If your Godot CI checks scripts like this, break one on purpose and see if it goes red.
Your translated layout test might be measuring a string your game never shows.
In Glassvow, act and boss names live in the content data, not the UI text table. Switch only the UI language and the Traditional Chinese test row reads a Chinese waystone phrase glued to English place names.
That line never appears on screen, so a pass or a fail on it means nothing. Our layout tests load the translated content too, so each row measures exactly what a player in that language sees.
If your game mixes UI strings with names from data files, check which one your test is really measuring.
One of our compressed textures has a full ASTC mip chain of 5,592,432 bytes. Our native upload path wants each request under 4 MiB. So a small engine patch we carry splits the chain into two complete, ordered batches. Mip layout, row pitch and source pixels stay exactly as they were, and every mip is checked before anything is allocated.
It isn't in a shipping build yet, and I'm making no speed claims. But if your Godot game has big compressed textures on mobile, look at how they reach the GPU.
James To retweeted
Octomiser does one thing: UK half-hourly electricity prices on your iPhone.
25 Oct, London's cheapest half-hour: -7.34p. 28-30 Oct: never under 25p.
What changed? Wind. October's 7 windiest days averaged 13.68p. The 7 stillest: 32.38p.
Full month: where-did-the-cheap-electric…
Same lesson for UI, on my card game.
"Looks right" kept coming back on the phone. Now the test reads the rectangles the player sees and holds them apart: 2,376 of them, across phone, pad and desktop, in two languages.
A number you can fail beats a screenshot you can squint at.
The level matched the concept art when the score hit 91 out of 100.
Not when it looked right to me.
That is the whole trick.
Claude Opus 5.5 + Godot 4.7, one reference image, 33 minutes and 5 seconds of Opus churning, a full 3D level out the other end.
Step 1 -> Pick one reference image. That is the target.
Step 2 -> Opus writes a generator in Rust that builds the level from a seed.
Step 3 -> Small pieces only: single stones, mixed flagstones, single planks, chains.
Step 4 -> Zero textures. Stone, wood, brass, cloth, flame, all procedural shaders.
Step 5 -> Opus writes a comparison script: render vs reference on color, light, contrast, detail, scored 0 to 100.
Step 6 -> Scene fixes before anything cosmetic: lighting, haze, layout.
Step 7 -> A LUT auto-fitted to the reference as the final pass.
Step 8 -> Render -> score -> side-by-side -> change one thing. Repeat.
Who did what:
> Rust + Godot: the generator and the scene.
> Opus 5.5: all the code and the scorer.
> Me: one change per loop, nothing more.
No image gen -> 3D model -> Cleanup pipeline.
One generator instead of 100 assets, and not a single generation credit spent.
Our game's content file was one line long. 65,591 bytes.
That's how a balance commit raising two boss HP curves showed up in review as "1 insertion, 1 deletion".
Glassvow started as a port of a web card game. The content file claimed to be a straight capture of the original. When we finally compared it with a fresh capture, it differed by 12 values and 5 keys: five boss HP curves raised, one relic reworked, two mechanisms added. All deliberate. All one script run away from being silently reverted.
The test meant to guard it compared the file with itself. It would have passed at any amount of drift.
What we did: deleted the capture script, pretty-printed the file to 5,485 lines, and stopped calling it a capture. Then we stopped benchmarking against the original altogether.
If you're porting anything: diff your "faithful" data against a fresh capture today, and never keep data on one line.
