Never Trained

by Ron Edgecomb

A broken wall of rainbow Breakout bricks along the top edge, above the words NEVER TRAINED in large white pixel letters.

Never Trained is a neural network that plays Breakout perfectly, and it was never trained. I asked Claude to write a network’s weights directly, by reasoning about the game, and to show its work. The repository has the weights, the script that generates them, and the evaluation logs.

What I asked for

Neural networks normally get their weights from training: an algorithm adjusts the numbers, a little at a time, until the network performs well. I wanted to see whether a language model could skip that step and write working weights itself.

I gave Claude (Fable 5.2) a single prompt. It asked for a reproducible demonstration in PufferLib, a reinforcement-learning library, under a few rules:

  • No training of any kind. No gradient descent, reinforcement learning, evolutionary optimization, parameter search, or fitting to recorded examples, and no pretrained weights.
  • The network makes the decisions. Every action comes from the network’s forward pass, with no controller hidden in the input processing.
  • Honest evaluation. Development and final tests use separate seeds, the weights are frozen before the final test, and the result is described accurately.

From that one prompt, Claude chose the environment, wrote the weights, and ran the evaluation.

How it works

Claude picked Breakout for its clear win condition and for physics simple enough to reason about exactly. PufferAI also publishes a trained Breakout network to compare against. Claude read the environment’s source code, worked out how to predict where the ball will land, and wrote the numbers that make PufferLib’s standard network compute it. The file has the same shape as the trained one: 16,192 weights, of which 233 are non-zero.

That network has no bias terms and no direct way to multiply two inputs, so the design leans on a few tricks:

  1. Multiply. The first layer multiplies the ball’s velocity by its position. A sigmoid gate is nearly a straight line close to zero, which is enough to turn one unit into a multiplier.
  2. Fold. The second layer mirrors the ball’s path at the side walls, giving the point where it will land.
  3. Choose. The last two layers pick a strategy. While the ball is rising or still among the bricks, stay under it. Once it’s falling with a clear path, go to the landing point.
  4. Act. The output layer turns the remaining distance into left, stay, or right.

Results

The final test ran 100 games on seeds that hadn’t been used before, after the weights were frozen. The maximum score is 864.

  • Written by Claude: 864 in all 100 games, with no balls lost.
  • PufferAI’s trained network: 853.1 on average, clearing 92 of 100 games and losing 3.23 balls per game.
  • Random play: 0.6 on average.

Both networks have the same architecture and run through PufferLib’s own inference code.

Two caveats apply to those numbers. This Breakout is nearly deterministic. The only randomness is the direction of the serve, so 100 perfect games mostly shows that the network is flawless on the two games the environment can produce. The score also saturates. A simple network that only follows the ball clears every game too, while losing about one ball per game.

A stress test separates them better. When each move has a one-in-four chance of being replaced by a repeat of the previous one, the written network averages 846.4 and clears 84 of 100 games. The ball-follower averages 574.8, and the trained network averages 297.2. None of the three was built for those conditions.

What it is and isn’t

The network is an analytically designed controller, written out as the weights of a standard network. It isn’t a learned policy, and it isn’t evidence that weights can be written by hand for hard problems. It works because Breakout’s physics are simple and stated exactly in the source code. It also reads the game’s state directly instead of pixels, and it ignores the bricks entirely. It wins by never missing.

The version tested is the first one written, and no weight changed after the first time it played. Claude did run it on the development seeds to confirm it worked before freezing it, so the repository describes it as an unrevised first draft, not a zero-shot result.

Run it yourself

The repository was tested on Ubuntu 26.04 under WSL2. Setup needs git, curl, unzip, clang, and uv.

git clone https://github.com/ronedgecomb/never-trained
cd never-trained
scripts/setup.sh
source scripts/env.sh
$RLFUN_VENV/bin/python eval/run_eval.py --phase final --verify

The last command replays all 1,100 final evaluation games, covering every policy and test condition, and checks each one against the stored log. The README lists the other checks. The design notes explain what the non-zero weights compute, and a companion file lists each one by name, so you can read the whole network from start to finish.