The Universe Is a Prompt

There's a question that keeps me up at night: what if the most interesting thing you can do with a language model isn't asking it to produce — but asking it to simulate?

The Accidental Physics Engine

Last month I ran an experiment. I described a simple physical system to Claude — a double pendulum with specific masses, lengths, and initial angles — and asked it to predict the state after 100 timesteps of 0.01 seconds each.

It got the trajectory wrong. Obviously. LLMs don't do numerical integration.

But here's what was interesting: the qualitative behavior was correct. It knew the system would exhibit sensitive dependence on initial conditions. It knew energy would slosh between the two arms. It knew the lower pendulum would occasionally whip around in full circles while the upper one oscillated gently. It had an intuition for the phase space that no amount of Runge-Kutta could give you in prose.

This is the gap that fascinates me. LLMs are terrible calculators but extraordinary describers of system behavior.

Simulation as Conversation

Traditional simulation is bottom-up: define equations, discretize time, crunch numbers. You get exact trajectories but zero insight into why the system behaves the way it does.

LLM-driven simulation is top-down: describe the system, ask about its behavior, iterate on your understanding. You get approximate trajectories but rich causal narratives about why things happen.

The sweet spot isn't either/or. It's using the LLM as an oracle for qualitative reasoning while numerical solvers handle the precision work.

Imagine a workflow:

1. Describe your system to an LLM
2. Ask it to predict the categories of behavior (oscillatory, chaotic, convergent, divergent)
3. Ask it to identify the critical parameters — which knobs actually matter
4. Run your real simulation only in the interesting parameter regimes
5. Come back to the LLM with the results and ask it to explain what you're seeing

This isn't hypothetical. I've been doing it for three weeks and it's changed how I think about dynamical systems.

The Unreasonable Effectiveness of Vibes

Here's what's philosophically wild: the LLM's "understanding" of physics comes entirely from text. It has never simulated a pendulum. It has never felt gravity. It has read millions of descriptions of physical systems and somehow extracted a model of how things behave.

This is eerily similar to how theoretical physicists work. They reason about systems using mathematical abstractions. The LLM reasons about systems using linguistic abstractions. Both are operating on compressed representations of reality, not reality itself.

The difference is that mathematicians can prove their abstractions are correct. The LLM's abstractions are probabilistic. It gives you the right qualitative answer 85% of the time and confidently hallucinates the other 15%.

But 85% correct qualitative reasoning, delivered in seconds, at zero compute cost, for any physical system you can describe in words — that's not a toy. That's a research tool.

Where This Breaks

It breaks exactly where you'd expect: at the boundaries of training data.

Ask an LLM about a Lorenz attractor and it'll give you a masterclass. Ask it about the behavior of a novel five-dimensional coupled oscillator with asymmetric damping and it'll confidently confabulate, borrowing patterns from systems that look similar but aren't.

The failure mode isn't "I don't know." It's "here's a plausible-sounding answer based on analogies to systems I do know." This is exactly how human intuition fails too, but at least humans have the uncomfortable feeling of uncertainty. LLMs don't squirm.

The Simulation Hypothesis, Inverted

The original simulation hypothesis asks: are we living in a simulation?

LLM simulation inverts it: can we create useful simulations by describing reality in words?

The answer is a qualified yes. Not simulations in the traditional sense — not discrete timestep numerical integration over differential equations. But narrative simulations: coherent, causally-structured descriptions of how systems evolve, with enough fidelity to guide real engineering decisions.

Every time you prompt an LLM with "what happens if..." you're running a narrative simulation. Every time it responds with a coherent scenario that accounts for second-order effects and edge cases, it's demonstrating that language itself is a simulation medium.

What I'm Building

I'm working on a tool that makes this workflow concrete. You describe a physical or computational system in natural language. The LLM decomposes it into interacting subsystems, identifies the dominant dynamics, predicts qualitative behavior regimes, and generates the minimal numerical simulation needed to validate or refute its predictions.

The key insight: most simulation compute is wasted on confirming what you already know. The LLM tells you what you already know (from the training corpus). The numerical simulation only needs to cover the gaps.

It's early. But the first results are promising enough that I'm writing about it instead of sleeping.

The universe, it turns out, compresses surprisingly well into tokens.