A Language Nobody Wrote

The chip in the cave

Imagine someone in the Stone Age who finds a microchip.

They keep it. They have no electricity, no idea what it is for. One day they grind a lens and look closer, and all they see are fine scratches in a sliver of stone.

Suppose they wanted to change what it does. The obvious move would be to make a tiny tool and adjust the scratches. But that is not how chips are made. Nobody draws the scratches. Engineers describe what the chip should do in a high-level language such as VHDL, and a long chain of tools compiles that description down into the pattern in the silicon. The scratches are the last step of a process the finder cannot see.

I think we are that finder, and the body is that chip. We look closer and closer, and we adjust what we can see: one protein, one receptor, one enzyme at a time. That is what most medicine is. A molecule that fits one part, found by testing thousands of candidates and keeping the ones that work.

There is one difference that matters. The chip had a designer, and its source code exists somewhere. The body was never designed. There is no source code to find.

A program that never fails to run

And yet the body runs a program, and runs it with astonishing reliability.

• Two cells become a person. One fertilised cell divides into about 37 trillion, in the same body plan, almost every time.
• The face mirrors itself. The left side of a face matches the right, though no cell on one side can see the other. The cells are following shared rules.
• Healing knows when to stop. A cut in the skin regrows to the right shape, and then stops. Cells are not simply multiplying. They are aiming at a target, and they know when they have reached it.

The size of the program tells us something too. The human genome is about 3 billion letters, roughly 750 megabytes, smaller than many phone apps. It builds 37 trillion cells, each in its place. Storing where every cell goes would take far more than that. So the genome cannot be a blueprint. It must be a recipe: a compact set of rules that grows the body when it runs.

A compact description of the body exists, then, or the body could not be built from so little. We already know fragments of it.

• Turing’s patterns. In 1952, Alan Turing showed that two chemicals spreading and reacting can form spots and stripes by themselves. Many patterns in animals turn out to work this way.
• Coordinates. Cells learn where they are from chemical gradients, and decide what to become. That is how left and right can mirror each other.
• Master switches. A small family of Hox genes lays out the body from head to tail, in the same order in almost all animals. A change in one can make a fly grow legs where its antennae should be.
• Target shapes. Michael Levin’s lab at Tufts changed only the electrical state of flatworm cells, with no change to their genes, and the worms regrew with two heads. Cut again later, they regrew two heads again. The worm’s target shape had been rewritten.

These are high-level rules. They are not about any one molecule. They are what VHDL would look like, if biology had it.

Reading it like code

For most of its history, biology has been studied the way we used to write software: step by step. Gene A switches on protein B, which blocks C, which causes D. The pathway diagrams in textbooks look like flowcharts.

It has taught us a great deal. But it struggles with exactly the things the body does best. No flowchart explains why a face is symmetric or why a wound stops healing at the right moment. There are too many parts, and they all talk to each other at once.

In 2017, Eric Jonas and Konrad Kording tried a test I find hard to forget. They took a real chip, the 6502 from the Apple II and the Atari, and studied it with the tools neuroscience uses on brains: removing parts to see what breaks, recording single transistors, mapping the wiring. The tools produced findings that looked like insight. They explained almost nothing about how the chip worked.

It was the finder with the lens, done for real, on a chip whose source code we have.

What self-driving taught us

Driving had the same problem. For years, people tried to write it down as rules. If there is a pedestrian, brake. If the line curves, steer. The rules never covered the real road. There were too many cases, and the cases interacted.

What finally moved it forward was letting a network learn to drive from enormous amounts of driving. Nobody can write down the rules it uses. But it works well enough that cars with no driver now carry passengers in several cities.

Richard Sutton called this the bitter lesson. Across the history of AI, methods that learn from data have repeatedly beaten methods built on rules people wrote by hand: in chess, in Go, in speech, in vision, and, as it turned out, in biology.

Trained, not written

I think the reason the step-by-step approach struggles is that biology is not like sequential code at all. It was never written. It was trained.

• Evolution is the training. Billions of years of variation and selection, keeping what works, which is close to how a neural network is trained.
• The body works like a network. There is no central controller and no list of instructions. Trillions of cells respond to their neighbours in parallel, and a face emerges from all of them together.
• Predictable, but no formula. A trained network gives reliable answers, but you cannot point to the line that produces them. In the same way, a face reliably mirrors itself, and no single gene holds the symmetry.

Some programs can only be predicted by running them. The body predicts itself perfectly because it is the computer running the program. To predict it ourselves, we may need something that has learned the same rules, the way biology learned them: from examples.

The fold that broke

For fifty years, predicting how a protein folds from its sequence was the textbook example of a problem too hard to solve. Then AlphaFold, a neural network, solved it well enough to share the 2024 Nobel Prize in Chemistry.

It did not give us a theory of folding. There are no new equations in it, and no rules a person can read. It learned, from about fifty years of experimentally solved structures, a representation in which folding becomes predictable. The “impossible” layer turned out to be learnable.

And it did not stop at reading.

• Protein language models. Models trained on protein sequences, the way language models are trained on text, can now write new proteins. In 2024, ESM3 designed a fluorescent protein far from anything in nature, and it glowed.
• DNA language models. Evo, trained on genomes, has generated working gene-editing systems. In 2025, researchers reported using it to design whole genomes for small viruses that infect bacteria, some of which worked. It is early, but it is a genome written by a model.
• Design from a request. Tools such as RFdiffusion take a description, “a protein that binds this target, at this spot”, and return a sequence that often works in the lab. That is a compiler in miniature: you state what you want, and it produces how.
• Whole cells. Several groups are now trying to build an AI “virtual cell”, to do for a cell what AlphaFold did for a protein: predict what it does when something changes.

These are the first fragments of biology’s high-level language. Nobody wrote them. They were learned.

Can DNA draw a face?

There is a simple test of how far this has come. Can we look at someone’s DNA and predict their face?

So far, only crudely.

• Colour works. Eye colour, hair colour and skin tone can be predicted from DNA quite reliably. Forensic systems such as HIrisPlex-S are validated for it.
• Sex and ancestry work, and they explain a lot of what an average face looks like.
• Shape mostly does not. Researchers, among them Peter Claes and colleagues, have found hundreds of places in the genome linked to the shape of the face: the nose, the chin, the brow, the distance between the eyes. Each has a tiny effect, and together they still cannot draw a particular person.
• The bold claims did not hold. A 2017 study from Craig Venter’s company claimed to predict faces from genomes. Critics showed it was mostly predicting sex and ancestry, a face typical of a group, not the face of the person.

But identical twins share their DNA and nearly share their face. So the face is in the genome, together with the program that grows it. We cannot yet run that program.

It is a clean picture of the whole problem. The body draws the face perfectly, every time. The gene-by-gene approach has reached colour and ancestry. A model that learns from many genomes, each paired with a scan of the face, might go much further, the way AlphaFold went past the rules of folding.

It also gives a yardstick. When a model can look at a genome and draw the face, we will have learned to read the language. When it can write a genome that grows a face we describe, we will have learned to write it.

Writing a medicine

Medicine sits between those two. It does not need to write a face. It needs to describe one change and compile it.

With a learned, high-level model of a tissue, designing a medicine could look like this.

1. Describe the state you have. This tissue, in this person, behaving like this.
2. Describe the state you want. The same tissue, healthy.
3. Ask the model what gets from one to the other. A molecule, a sequence, a signal. This is the same kind of search an image model does when it works backwards from the picture you asked for to the input that produces it.
4. Test that one candidate. Not thousands.

Trials would not disappear. They would change their job: from the search itself to the check at the end, confirming a design the model already expects to work. That is how chips are made today. Nobody fabricates every guess. Designs are simulated and checked first, and only the good ones are made.

There is a further step. Today’s drugs work at the lowest layer: one molecule fits one protein. But if the body has high-level rules, target shapes and setpoints like the ones that stop a wound healing at the right moment, a medicine could work at that layer instead. Not “block this enzyme”, but “this tissue’s target is the healthy one; return to it”. The body already makes that call every time it heals. Medicine would be learning to make it too.

The layers above

Chips are built in layers: transistors, gates, logic, architecture. Each layer can be understood without the one below. Biology may have layers too, but we are learning them from the bottom up, and each one is harder.

• Proteins: largely readable now, and starting to be writable.
• Cells: the next layer, and the one the virtual-cell efforts are aiming at.
• Tissues: where most diseases actually live, in how cells behave together.
• The whole body: immunity, ageing, the mind. These may exist only at this level.

The bottleneck is data. AlphaFold could learn because decades of patient lab work had produced a large, clean library of solved structures. For cells and tissues, that library is only now being built: atlases of cells in which genes are switched off one at a time, so that a model can see what each change does. Each layer up will need its own library.

The hard parts

Data. The higher layers have far less clean data than proteins had. Gathering it is slow and expensive, and it may take decades.

Rare cases. Learned models are best at cases like the ones they learned from. A rare disease, or an unusual patient, is exactly where they are weakest, and exactly where medicine is most needed.

A compiler nobody can read. We would be designing medicine with a model that cannot explain itself. That is uncomfortable. It is also, arguably, how drug discovery already works: many drugs were in use long before anyone knew why they worked.

Emergence. Some behaviour may appear only at the level of the whole body. A model that has learned cells may never learn what cells do together.

Bugs ship into people. A bug in a chip costs a recall. A bug in a medicine that edits genes, or that copies itself, cannot be recalled. Checking the design matters more here than it ever has in silicon.

Power cuts both ways. A language that makes it easier to write a cure makes it easier to write other things too, and it would need to be governed with that in mind.

Time. Chips took about fifty years to go from the first transistor to modern compilers, and they had designers at every step. Biology starts from nothing designed.

Where I would start

• A public test of reading. A large, consented dataset of genomes paired with 3D face scans, and an open benchmark: how well can a model draw the face? It is a clear, measurable test of whether the language can be read above the protein layer.
• One tissue, one disease. A state-to-state model for one well-measured tissue in one disease, with the patients’ consent and the data to learn from, to see whether “from this state to that state” can produce a candidate worth testing.
• Build the libraries. The datasets each layer needs, gathered openly, because the next AlphaFold will depend on them the way the first one depended on fifty years of solved structures.

Others who have tried parts of this

• Cello, in 2016, compiled circuits written in Verilog, a language for chips, into DNA that ran in bacteria. It works because its parts were chosen to behave cleanly, so it describes what we add, not the body we have.
• A whole-cell model of the bacterium Mycoplasma genitalium, in 2012, simulated every known gene of one simple organism.
• mRNA vaccines keep the platform fixed and change only the sequence. Moderna had its COVID vaccine sequence designed within days of the virus’s genome being published.
• AlphaFold, ESM3, Evo and RFdiffusion are the first learned fragments of the language.
• Michael Levin’s lab is working on editing the body’s target shapes directly.

What I add is a way of putting these together: that the body is predictable because it runs a learned program, that the right way to describe it is probably a learned model rather than a written one, and that medicine could be designed by asking that model to get from the state we have to the state we want.

The finder in the cave never learned to read the chip. They trained something that could, and asked it to make the change.