A weight-space programming experiment: a racing driver written, not trained
Researchers have shown GPT-6 Astra can natively read and write neural network weights. So I had it write a small one that drives a race car.
In the researchers’ demos, Astra looks at the raw weights of a language model and edits a fraction of them to stop it going round in loops, which takes its score on a math benchmark from 7.9% to 48.1%. They also had it write small neural networks from scratch.
That sounded too wild not to try, so I asked Astra to build me a neural network from scratch. I started small and asked for a calculator, and five minutes later I had a working one with 50 neurons. It adds and subtracts exactly, and multiplies and divides small numbers to within 1%. It looked like Astra had simply calculated which weights would produce the output I asked for. In effect it translated ordinary arithmetic into the kind of math a neural network does, which is weighted sums and cut-offs.
My guess is that Astra works out the rule first and then writes it down as weights, and for something this small it can do it in a single prompt. Kind of like vibe coding, with the program coming out as weights instead of code. So vibe-training, minus the training?

Training a
neural network
Vibe-training a
neural network
So then, could we build something more complicated from scratch rather than train it? I suggested a simple 2D game, maybe a race track, and Astra built the game and a network to drive it.
Looks legit to me. Every steering and throttle decision in that demo comes from a small network whose weights Astra wrote, with no training involved. Let’s get into how we got here. Astra wrote every weight, and I mostly kept asking for something harder to see what would break.
The setup
The network controls a car on a track. A few tracks are fixed, like the Technical loop in the demo above, and most come from a random generator that makes flowing, mixed and tight tracks. The network is given wall sensors, its speed and turn rate, and later on a map of the road ahead. It controls the steering and the throttle, where negative throttle brakes, and its goal is fast laps without collisions.
A network is mostly weights, and each weight is a number that sets how strongly one input pushes on one control. Here is a toy version with only two of them, where dragging a slider changes what the car would do.
From weights to driving controls
- Bend
- +0.60
- Base throttle
- +0.85
Try driving the same car yourself below.
First attempt
The first network was tiny, with 11 inputs, 11 neurons and 2 outputs, which makes 156 weights. Astra gave each neuron a job and a name, like “Turn right”, “Brake” or “Left wall”, and wrote its weights to do that job without any training. Here is “Turn right” with one weight per input and comments that I added.
const turn = [
-0.75, // wall sensor, left 90°
-0.9, // left 60°
-1.2, // left 40°
-1.7, // left 20°
0, // straight ahead
1.7, // right 20°
1.2, // right 40°
0.9, // right 60°
0.75, // right 90°
0, // speed
-0.5 // turn rate
];Each sensor reports how much room there is in its direction. Left is negative and right is positive, so the neuron fires when there is more room on the right. The last weight calms it down when the car is already turning, and “Turn left” is the same list with the signs flipped.
Half an hour after I suggested the idea, this network was lapping the three tracks Astra had drawn for it. That felt a bit too easy, so I asked for random tracks it had never seen, with the weights left alone, and the tight bends caught it out. Every one of its crashes was on a tight track like this one.
| Tracks completed | 564 / 600 (94.0%) |
|---|---|
| Average time per lap | 7.55 s |
Second attempt puts steering first
The sensor readings from the crashes showed the cause. The long diagonal sensors were pulling the car toward open road even while the inside wall was closing in, so the side sensors had to count for more. Astra tried a dozen combinations of weights in the simulator and kept one that cleared every crash. Here is how much each pair of sensors counts in “Turn right”, before and after.
side sensors at 90° 0.75 → 2.25
side sensors at 60° 0.9 → 2.7
forward diagonals at 20° 1.7 → 1.2The same edit went into three more neurons, which comes to 24 weights in all. The revised network cleared those crashes, and then finished all of 600 fresh tracks that were opened only after the fix was settled, at the cost of slightly slower laps. Both tables show that fresh batch.
| Tracks completed | 600 / 600 (100.0%) |
|---|---|
| Average time per lap | 7.78 s |
A faster car has to look ahead
A third pass over the same 156 weights made the car quicker, and it then finished every one of 2,999 fresh tracks. The laps still looked slow to me, and it turned out that on the easier tracks the car was already flat out against its speed limit. So I asked for the speed cap to come off.
A car that fast needs to see a bend coming, so I asked for the shape of the road ahead as an input.
The dots are the points on the road ahead that the network is given, out to 1,100 units on a loop that is about 1,900 long. Astra connected only the five filled dots, so the network uses nothing beyond 400.
Stuck on laps in a row
I then asked for laps in a row, so the car carries its speed into each new lap. On 600 fresh tracks the network still finished every opening lap, but it finished five laps in a row on only 540 of them, and on the Technical loop it crashed on its second lap.
The first thing that helped was in the steering. Astra had the network work out how quickly the car needs to turn to follow the road just ahead, so that it can start turning in time. That number is the car’s speed times how sharply the next 80 units of road bend. A network like this cannot multiply two of its inputs, so Astra built the multiplication out of 68 extra neurons. With that in place all 600 tracks finished five laps, and on the Technical loop the car got as far as its sixth lap.
It kept crashing there until Astra added a braking rule that slows the car down when the road ahead bends too sharply for its current speed. After that the car finished 20 laps in a row on every fresh track we gave it.
I also kept thinking a bigger network would get the lap times moving, and it grew to 132 inputs, 148 neurons and 19,646 weights. It turned out it didn’t need the room, since Astra filled in just 739 of those weights and left the rest at zero.
| Tracks completed | 599 / 599 (100.0%) |
|---|---|
| Average time per lap | 2.91 s |
One more edit changes two weights
By now the car was finishing every track we gave it, so the next push was about speed. The braking rule slowed the car for every big bend, including long smooth ones it could have held at speed. Astra updated the weights to look for changes in how sharply the track was bending, comparing the next 80 units of road with the 80 after that. This required changing just two weights in the network, one in each of the two neurons that brake for bends, and the steering weights did not change at all.
"Turn-change brake right" 0 → -2
"Turn-change brake left" 0 → +2Those two numbers made 183 of 599 tracks faster and none slower, and took 20 laps of the Technical loop from 50.18 seconds to 49.28. What I like about this edit is that I can actually follow it. Each neuron already added up the bend over the next 160 units, so taking the first 80 away twice leaves the second 80 minus the first.
| Tracks completed | 599 / 599 (100.0%) |
|---|---|
| Average time per lap | 2.89 s |
Astra was the one who suggested we stop there, since each edit was buying less. The one idea it still liked was giving the network memory, and seven of the eight memory designs crashed while the eighth was slower.
Training a network from scratch
Naturally I wanted to know how a trained network would do, so we trained one on the same setup with Proximal Policy Optimization (PPO), and that turned out to be the harder half. The first long run went for 100 million steps. It was at its best a quarter of the way in and then slowly forgot how to drive, and by the end it finished 87 of our 300 test tracks. So we went back to its 25 million step checkpoint and trained on from there with a smaller learning rate, checking on it every million steps or so and stepping in whenever it started to get worse. I stopped that second run at about 50 million steps, and the checkpoint we kept, from 47.5 million, finishes 297 of the 300. It is a bigger network with 67,202 weights, and none of them are zero.
The test is 20 laps on each of 300 random tracks that were kept out of training.
| Measure | Written | Trained |
|---|---|---|
| Random tracks completed | 300 / 300 | 297 / 300 |
| Average time per lap | 2.95 s | 2.20 s |
| On flowing tracks | 1.77 s | 1.87 s |
| On mixed tracks | 2.84 s | 2.16 s |
| On tight tracks | 4.27 s | 2.58 s |
| Club circuit, 20 laps | 42.77 s | 50.98 s |
| Double bend, 20 laps | 42.48 s | 54.25 s |
| Technical loop, 20 laps | 49.28 s | Crashed on lap 2 |
The trained network is about 25% quicker per lap, and on tight tracks the gap is much wider than that. It also crashed on three tracks, while the written one finished all 300 and was the quicker of the two on flowing tracks and on the fixed tracks it grew up on. So neither wins outright.
Here is a typical tight track from the 300, with the written network in amber and the trained one in blue.
Keep in mind that the trained network comes from one random seed, that we picked its checkpoint on these same 300 tracks, and that I stopped the run by choice, so a longer one might have done better. The written one is not crash-proof either. It still crashes on three tight tracks we found outside these 300.
Conclusion
This looks promising. The trained network ended up quicker, but it took a while to train and a decent amount of compute, and its 67,202 weights do not come with an explanation. The written one took a dozen versions and about a day of trial and error, and what I got in return is a network I can read. Every neuron has a name, and when the car brakes I can point to the weights that did it.
For narrowly specified tasks, it might be possible to get up and running with a reasonable neural network without going through the hassle of training it. I, for one, am excited to use such networks in games.
You can try every version, and download its weights, in the full lab.