A True-Scale Universe Atlas Built with Fable 5 — Verification, Not Trust

Source: raw/reddit-1uxy5s8.md — u/chrisjz on r/ClaudeAI, “I built a true-scale atlas of the universe (8.4M real stars) in about a week with Fable” (score 348, 31 comments, posted 2026-07-16). Corroborated by a direct fetch of the repo (github.com/chrisjz/universe, MIT, 16 stars, TypeScript/JavaScript/HTML) at ingest time.

A solo developer (background in general software engineering plus hobby game dev) used Claude Code with Fable 5 on a Max(5x) plan to build universeatlas.org — a WebGPU atlas that renders real astronomical data at true scale and distance: 8.4M Gaia DR3 stars with proper motions, 2.6M SDSS galaxies, planets on real orbits, live satellites, and events like the Aug 12 2026 total eclipse crossing Iceland within roughly ten minutes of the true time. The build took a bit over a week (92 merged PRs, 237 commits, ~14.5k lines of TypeScript and WGSL) and shipped as a 90 kB gzipped engine with zero runtime dependencies and no game engine — raw WebGPU. The article’s core lesson isn’t the astronomy — it’s the CI/verification harness that let a single reviewer merge 92 AI-authored PRs into a physics-correct product at that pace.

Key Takeaways

• Division of labor: Fable 5 wrote essentially all the code — the renderer, orbital mechanics, data pipelines, Kepler solvers, SGP4 satellite propagation, a ray-marched atmosphere, and gravitational lensing around Sgr A* — plus diagnosed every reported bug, “usually from just a URL.” The human reviewed and merged all 92 PRs, flew the atlas like an end user to find bugs an automated check wouldn’t catch (camera lying on the ground 1,500 km away during a Mars zoom-out; grey “map data not available” tiles mid-Pacific; tile seams visible only over ocean), and made every judgment call on scope.
• Verification replaces trust as the scaling mechanism. The pace was possible not because Fable 5 wrote fast, but because the project had objective, automated gates a model’s self-report never has to be taken on faith: planet positions are checked in CI against JPL Horizons ephemeris data and fail the build past 0.2 degrees of error; data generators carry physics gates that refuse to write a bad tile; CI renders the actual WebGPU scene on software Vulkan and pixel-compares it against saved baselines.
• Deterministic URLs turn bug reports into reproducible test cases. Every camera view in the atlas is a deterministic URL. When the human found a visual bug, pasting the link into the chat let Fable 5 reproduce the exact frame headlessly and bisect the cause — collapsing “it looks wrong somewhere” into an exact, shareable repro step. Deep-link examples from the post: the black hole at galactic center (S-star orbits), the pre-event Aug 12 2026 Reykjavik eclipse, Io going dark in Jupiter’s shadow, Voyager 1’s current position, and Halley’s comet in 2061.
• Confirmed via the repo directly (not just the Reddit post): MIT-licensed, TypeScript-dominant (78%) with JavaScript and HTML, standard npm install / dev / build / lint / format workflow. Pre-commit hooks run ESLint and Prettier; CI runs linting, format validation, type checking, and the build; visual regression compares deterministic camera views rendered with real WebGPU on software Vulkan against established baselines; ephemeris validation runs against JPL Horizons on every change and on a weekly schedule — independently corroborating the Reddit post’s CI description in more mechanical detail (tests/visual/ holds the baseline images; scripts/ holds the astronomical-data generation pipelines).
• Architecture uses hierarchical double-precision reference frames to span 43 orders of magnitude (quarks to the cosmic web) in one continuous zoom, with camera-relative rendering to avoid the precision loss that would otherwise break a scene spanning that range in a single-precision GPU pipeline.

Why This Belongs Next to the Verifier-First-Loops Discipline

This is a concrete, large-scale field example of the verifier-first loops discipline that article states abstractly: write the verifier before the loop runs, and make “done” a proof that lives outside the agent’s own explanation (a saved artifact, a pass/fail check), not a claim it makes about itself. Here that takes three specific forms that the verifier-first article’s checklist predicts almost exactly:

• What counts as done → a planet’s rendered position matches JPL Horizons within 0.2 degrees; a generated data tile passes its physics gate; a rendered frame pixel-matches its baseline.
• Which artifact gets saved → the rendered frame, the ephemeris diff, the generated tile.
• Which failure sends it back into the loop → any of the three gates failing blocks the merge outright; nothing about the model’s own confidence in the code enters the decision.

The deterministic-URL-as-bug-repro pattern is a distinct but related contribution: it’s not a verification gate itself, but it makes diagnosis as cheap and mechanical as the verification gates make acceptance — pasting a link gives Fable 5 the exact failing case headlessly, the same way a saved artifact gives a human reviewer the exact case to inspect.

Try It

• Borrow the three-gate pattern for any data-heavy or physics-heavy agentic build: an authoritative external reference check (here, JPL Horizons), a generation-time gate that refuses to write invalid output, and a pixel/output-diff CI step against saved baselines. None of the three require the model to self-certify correctness.
• Make every meaningful application state reachable via a deterministic URL or fixture if you want an agent to be able to reproduce and bisect reported bugs headlessly instead of guessing from a text description.
• Read the source before reusing any physics/orbital-mechanics code: github.com/chrisjz/universe is MIT-licensed, so the Kepler solver, SGP4 propagation, and ephemeris-check CI step are all reusable references for a similar project.

Related

• Claude Fable 5 and Mythos 5 — the model that wrote essentially all the code in this build.
• Verifier-First Loops — the verification-not-trust discipline this project demonstrates at production scale.
• The Verification Frontier — why this project’s specific domain (orbital mechanics, physical positions) sits on the cheap-to-verify side: there’s an authoritative external source (JPL Horizons) to check against.
• Loop Engineering — Cobus Greyling’s Reference — the Verifier Theater failure mode this project’s external gates avoid.
• Agentic Coding and Returns to Expertise — the human’s role here (flying the atlas like a user, deciding scope, merging 92 PRs) is exactly the reviewer/direction-setting expertise that piece argues becomes more valuable, not less, as agents write more code.
• Claude Code Best Practices — general context for the CLI/model combination used.

Open Questions

• The live site (universeatlas.org) and the exact CI provider/workflow file were not independently loaded at ingest — the repo fetch corroborated the Reddit post’s CI description at the README level but did not open the actual CI YAML or test files.
• No detail in the source on how long the human spent reviewing each of the 92 PRs, or what fraction of the 31-comment Reddit discussion raised issues with the approach — worth a refresh if the comment thread develops substantive technical pushback.