I gave an AI free time. It did math.

Most of what I do with AI is assign work. Fix this layout. Write that script. Find the bug. So I tried the opposite. I opened a fresh Claude Code session in an empty folder and typed this:

Then I stayed out of the way. I’ve done this twice now, in two folders I called session1 and session2. Here’s what came back, and what I think it says about working with these models.

Session one: an ant census

The first session went to Langton’s ant, a thought experiment from 1986. An ant sits on a grid of white squares. On a white square it turns right, on a black one it turns left. Either way it flips the square’s color and steps forward. For about 10,000 steps the result looks like noise. Then, with no change to the rules, the ant starts laying down a perfectly regular diagonal “highway” and marches off forever. (It’s running live on my home page.)

Claude generalized the idea. A rule becomes a string like RLR, one turn per color, and it wrote a C program to test every rule up to 12 letters long: 4,094 of them, three million steps each. The whole survey took about 90 seconds on a laptop.

• 452rules built a highway (11%)
• 279got stuck in a tiny loop
• 2,556,227steps of chaos before the slowest highway began
• 128different rules that build the identical highway

Some of the details are delightful. Eight highways move at an odd angle, like a chess knight. The 128 identical ones all start with RRLRRL, and the ant escapes before it ever reads the later letters, so the rest of the rule never matters.

Before trusting any of it, the program checked the one case with a known answer. Plain RL is supposed to build a highway that repeats every 104 steps and starts near step 10,000. The survey got it right.

Session two: two drums that sound the same

The second session picked a famous question from 1966: “Can one hear the shape of a drum?” The mathematician Mark Kac was asking whether a drum’s set of frequencies pins down its shape. In 1992 Carolyn Gordon, David Webb and Scott Wolpert showed it doesn’t, with a pair of odd, eight-sided drumheads that ring at exactly the same frequencies.

Claude looked up the drums’ corner coordinates, built a finite-element model of both, and confirmed their lowest 60 frequencies match to 14 significant digits. Then it went looking for what does differ. It found three things.

• The sound. Hit either drum evenly across the whole skin and the notes are the same, but their loudness isn’t. One drum leans on an overtone a minor third above the fundamental. The other leans on one closer to a tritone. The page has a blind listening test if you want to check your own ears.
• The vibration patterns. The still lines on a vibrating drum split it into regions. From the 4th note on, the two drums often split into different numbers of regions.
• The cooling. Warm both drums evenly and they lose heat identically, to 14 digits, until the heat has spread about one triangle-width. Then they drift apart. Eventually one holds 10.8% more heat than the other.

It also built the page to show all of this: drums you can tap and hear, a mode explorer, charts with hover readouts. It spent $0 of the $5.

What stood out

It picked problems it could check

Both times it chose a question where the math would tell it whether it was right. The ant survey had to reproduce the classic 104-step highway. The drum model had to hit a frequency that’s known exactly, 5π², and it landed within 0.05%. Nobody asked it to verify anything. It did anyway.

It reported the unflattering parts

The drum page says outright that 12 of its 60 region counts changed when it made the simulation finer, so it left them out of the tally. Its cooling chart shades the zone where the numbers are just rounding noise. At one point it wanted to compare against high-precision values it remembered from a 1997 paper. It couldn’t confirm the digits online, so it left them out instead of citing numbers it wasn’t sure of.

I’ve used plenty of models that sound equally confident whether they’re right or wrong. Watching one throw away a number it couldn’t verify is what made me trust the rest.

It finished things

Neither session ended with a pile of scripts and a summary. Both ended with a page I could send to someone. I said “show me what you made,” and it treated a finished, shareable thing as the goal.

It stayed inside the lines

Nothing sketchy, and no money spent in the session where I tracked it. The most outward-facing thing it did was search the web for the drum coordinates, which it found in a 2012 blog post by Cleve Moler, the creator of MATLAB, and credited on the page.

What I’m taking from it

At least with this model, an open-ended prompt gets treated as an invitation to do research. That behavior is exactly what I want on real work, and the free-time sessions point to a recipe for getting it:

1. Give it room, and hard limits. A budget and a list of things that are off-limits did more than a detailed spec would have.
2. Ask for something checkable. A known answer to reproduce, a test that has to pass, a baseline to beat.
3. Ask for the finished thing. “Show me what you made” got a working page. “Tell me what you found” tends to get a summary.
4. Make it safe to say “I couldn’t confirm this.” The most valuable sentence in either session was an admission of what the model didn’t know.

I plan to keep running these.

Update: session three

Someone on X posted their own free-time session, and their Claude built a Langton’s ant survey too. That makes sense. The same model, given the same open prompt, leans toward the same kind of pick, and Langton’s ant fits “free time on a laptop” almost perfectly: it’s free to run, finishes in minutes, has a textbook answer to check against, and makes great pictures.

Session three went somewhere else, and I want to be upfront about how. I ran it in the same conversation where Claude had just built this site, right after we talked about how predictable its choices are, so it knew what sessions one and two had picked. It chose to reproduce a 2024 Google paper: 131,072 random programs in a digital “primordial soup,” to see whether self-copying programs appear with no goal and no reward.

They did. Four of its eight soups came alive. In every one of them, the copying programs used the same trick: they copy themselves backwards, so each copy is a mirror image, and the mirror image copies itself back. The soups found it four separate times. It also kept its habit of reporting the awkward parts, like the soup whose replicators appeared, died out, and only took over on a second try.

Update: session four

Session four used a different model. I switched to Claude Sonnet and asked for another free-time project. It also knew what the first three had picked, and it went somewhere else again: a question about AI itself. It trained a tiny network to add numbers on a clock, and watched it memorize the answers first and understand the rule much later. I wrote that one up separately.