Vibe-Coded Simulations Are the New Study Notes

A post that hit the Hacker News front page this weekend describes a learning workflow that would have sounded absurd two years ago: when Laurentiu Raducu wants to understand a hard topic — EUV lithography, rocket engines, chip fabrication — he doesn't ask an LLM to explain it. He asks a coding agent to build him a playable, low-poly, RollerCoaster Tycoon-style simulation of it, then deploys the thing to GitHub Pages and learns by poking at it.

Strip away the retro aesthetic and there's a real shift underneath: the LLM's job is moving from tutor to fabricator of learning artifacts. That shift is genuinely valuable. It's also more dangerous than the post admits, and the gap between those two facts is worth being precise about.

Explorable explanations finally got cheap

Interactive learning artifacts aren't new — they're just historically expensive. Bret Victor made the case for them in his 2011 essay Explorable Explanations, and a small guild of practitioners — Nicky Case, Amit Patel of Red Blob Games, Bartosz Ciechanowski — has spent the years since proving that a good interactive model beats a good paragraph for building intuition. Bartosz Ciechanowski's mechanical-watch and GPS explainers are legendary precisely because almost nobody can afford to make them: each one represents months of a rare person who is simultaneously a domain expert, a visualization designer, and an engineer.

That labor cost is why explorables stayed a boutique genre while YouTube ate the world. What coding agents like Claude Code and OpenCode change is the economics: a mediocre-to-decent interactive simulation of an arbitrary topic now costs an afternoon and a few dollars of tokens. You're no longer choosing between Ciechanowski quality and nothing. There's a middle tier — personal, disposable, good-enough explorables — that simply didn't exist before, and the retention argument for them is sound. Mapping concepts onto spatial objects you can manipulate is close to how memory actually works; it's the same reason memory-palace techniques outperform rereading. For learning styles that bounce off dense prose, this is a legitimately better interface, not a gimmick.

There's also a subtler benefit the post touches only glancingly: specifying the simulation is itself the study session. To tell an agent what the stages of EUV lithography are and how they should interact on screen, you have to extract and organize that structure first. That's the Feynman technique wearing a coding-agent costume — you learn a thing by being forced to articulate it — and it may account for as much of the retention as the artifact does.

Self-review is not fact-checking

Here's where the workflow goes wrong. Step two of the method is asking the model to review its own output for correctness, after which the author declares the results "100% accurate and free of hallucinations." That claim doesn't survive contact with the evidence — including evidence from the author's own projects.

Intrinsic self-correction — a model checking its own reasoning with no external signal — is one of the better-studied failure modes in the field. The ICLR 2024 paper Large Language Models Cannot Self-Correct Reasoning Yet from Huang and colleagues at Google DeepMind found that models asked to review their own answers frequently made them worse, not better. A model that hallucinated a plausible-sounding detail about pellicle membranes in a lithography sim will, on review, tend to find that detail plausible — it came from the same distribution that generated it.

And the community stress test already happened. When the author's TokenTown — a town-themed visualization of LLM tokenization — hit Hacker News a couple of weeks before this post, commenters flagged jargon-heavy explanations that read like unedited model prose, visual bugs like vehicles crashing through the scene, and pointed learners instead to Brendan Bycroft's LLM visualization, a hand-built expert artifact. The thread on the learning post itself surfaced the same worry, with one commenter describing the familiar cycle: "oh of course you're right — what I just told you was completely wrong."

The stakes are higher than they are for text, not lower. A wrong sentence invites skepticism; a wrong simulation launders error into intuition. If the sim shows the wafer moving through fab stages in the wrong order, you don't just read a false fact — you rehearse it, interactively, until it feels obvious. Bad explorables build wrong mental models with exactly the stickiness that makes good ones valuable.

How to run this workflow without fooling yourself

The fix isn't to abandon the method; it's to move verification outside the model. Concretely:

• Split research from build. First have the agent produce a written spec of the domain — stages, quantities, causal relationships — with citations to primary sources (ASML's own EUV documentation, textbook chapters, vendor datasheets), and read those citations. Then have it build the sim from the spec. You're reviewing a two-page document, not reverse-engineering claims out of Three.js code.
• Verify against a canonical artifact, not the model. For LLM internals, click through Bycroft's visualization after playing your own sim and note where they disagree. Every serious domain has an equivalent reference; diffing against it is the actual accuracy step.
• Treat sims as disposable hypotheses. The GitHub Pages deploy step is fine for sharing, but resist the temptation to present a personal learning artifact as teaching material. TokenTown's reception shows what happens when an unverified study aid gets an audience.
• Test yourself outside the sim. If you can't answer questions posed from a real source afterward, the sim taught you the sim, not the domain.

The verdict

The direction is right and the epistemics are wrong. On-demand explorable explanations are one of the most promising things cheap code generation has produced — a genuine new tier of learning material between passive video and months-of-labor masterpieces, and worth adopting this week if hard technical domains are part of your job. But "the model checked its own work" is not a verification strategy, and anyone claiming 100 percent hallucination-free output from that loop is telling you they haven't looked hard enough. Generate the sim, enjoy the retention — and keep a primary source open in the next tab.