The One-Billion-Line Goal

← All posts

A tale of two kinds of software

Imagine you are using a weather app on your phone. You tap the icon, and it takes an extra half-second to load. Annoying? Sure. Dangerous? Not at all. The app eventually shows you tomorrow’s forecast, you grab an umbrella, and you move on with your day.

Now imagine a different piece of software. This one controls the cooling system inside a nuclear reactor. If a single number in the code is wrong — a temperature threshold set ten degrees too high, a valve timing off by one second — the consequences are not “annoying.” They can be catastrophic. Every line of that code must be exactly right.

These are two fundamentally different worlds. The weather app lives in a high-fault-tolerant world: small mistakes are absorbed, patched, forgiven. The reactor software lives in a low-fault-tolerant world: small mistakes can cascade into disasters.

Most of the AI coding you hear about today — autocomplete suggestions, chatbot-generated scripts, AI-built websites — lives comfortably in the first world. And it does a good job there. But the second world? The one where a misplaced decimal point can cost lives or billions of dollars? AI is barely getting started.

That second world is where PrinciplePhysics works. And this post is about why we believe it is the most important frontier in AI.

How big is “real” software?

Before we talk about AI, let’s talk about scale. Most people — even many programmers — underestimate how enormous the software behind everyday life really is. Here are some real numbers:

• Your car. A modern car runs on roughly 100 million lines of code. The engine control, the braking system, the airbags, the infotainment screen — all coordinated by software. A high-end vehicle has more code than a fighter jet.
• A passenger airplane. The Boeing 787 Dreamliner runs on about 14 million lines of flight-critical code. Every line is tested, audited, and certified, because at 35,000 feet there is no “restart the app.”
• A hospital MRI scanner. Somewhere between 3 and 10 million lines. The code reconstructs images of your brain from raw magnetic signals. If the math is wrong, the image is wrong, and the diagnosis could be wrong.
• A nuclear power plant. The control and safety systems together run tens of millions of lines. These must be correct under every scenario — including scenarios the engineers hope will never happen.
• Global finance. A single large bank may run 50 to 200 million lines of code across its trading, risk, and settlement systems. When this code miscalculates, the losses are measured in billions — as we have seen more than once.
• The Large Hadron Collider. The experiment software at CERN runs into the tens of millions of lines. Physicists use it to reconstruct what happens when particles collide at nearly the speed of light. Wrong code means wrong physics.

Now zoom out further. Google’s entire codebase — the software behind Search, Maps, Gmail, YouTube, and everything else — is estimated at over 2 billion lines. Not all of it is low-fault-tolerant, but large portions of it are: the ad billing system, the security infrastructure, the core search ranking.

The pattern is clear: the software that runs the real world is enormous, and the parts that absolutely cannot be wrong are growing the fastest.

Where AI stands today

Now let’s bring AI into the picture. In 2026, the most powerful coding AI models in the world are GPT-5.4 and Claude Opus 4.6. They are extraordinary tools. They can explain algorithms, generate working programs, debug tricky issues, and write clean code across dozens of programming languages.

But here is the catch: when the code must be exactly right — when there is no room for a wrong sign, a misplaced index, or a silently incorrect formula — these models top out at roughly 10,000 lines.

What does 10,000 lines look like in practice? It is enough to:

• Solve a textbook quantum mechanics problem from start to finish.
• Write a small but working physics simulation — say, two particles scattering off each other.
• Build a data processing pipeline that reads experimental measurements and produces a clean result.

These are real accomplishments. Five years ago, no AI could do any of them reliably. But 10,000 lines is still a tiny island in a vast ocean. Compare it to the numbers above: a car has 10,000 times more code. A single bank has 20,000 times more.

And it is not just about “writing more lines.” As a codebase grows, the number of ways things can go wrong grows even faster. At 10,000 lines, an AI can hold the whole program in its head. At 1 million lines, it must reason about code it wrote last week, code written by other AI agents, and code that interacts with the outside world in ways that are hard to predict. At 100 million lines, even the concept of “holding the program in your head” no longer applies to anyone — human or machine.

Why the gap matters

You might ask: does it really matter? If humans wrote all this software before AI existed, can’t they just keep writing it?

The short answer is: barely, and the situation is getting worse.

Software is growing faster than people. The amount of code the world depends on doubles roughly every few years. The number of qualified software engineers does not. We are already in a world where critical code ships with bugs because there simply are not enough human eyes to review it all.

Think about what this means in practice:

• In medicine, software bugs in radiation therapy machines have delivered lethal doses to patients. The infamous Therac-25 accidents in the 1980s killed six people — because of a software race condition that no one caught in review. Modern medical devices are far more complex.
• In finance, Knight Capital lost $440 million in 45 minutes in 2012 because of a software deployment error. One piece of old code that should have been removed was accidentally reactivated.
• In aviation, the Boeing 737 MAX crashes that killed 346 people in 2018 and 2019 were traced to a software system — MCAS — that pushed the nose down based on a single faulty sensor reading.
• In space, the Ariane 5 rocket exploded 37 seconds after launch in 1996 because a piece of code tried to fit a 64-bit number into a 16-bit space. A conversion error. One line.

These are not hypothetical risks. They have already happened. And the systems involved were far smaller than what we are building today. If human teams cannot keep up with the complexity of critical software at current scale, what happens when that scale doubles again?

We need AI that can help write and verify this code — not just the easy kind, but the kind that absolutely cannot be wrong.

Our vision: one billion lines

This is where PrinciplePhysics comes in.

Our goal is to build AI systems — we call them AI complexes — that can write, verify, and maintain low-fault-tolerant code at the scale of one billion lines.

Not 10,000. Not a million. One billion.

That number is not arbitrary. It is the scale at which AI becomes capable of building and maintaining the full software systems that the real world actually depends on — the reactor controls, the flight systems, the trading platforms, the power grids, the medical devices.

An AI complex is not a single chatbot. It is a coordinated system of multiple AI agents, each with a specific role:

• One agent reasons about the problem — what the code needs to do, and why.
• Another agent derives the method — working from first principles rather than copying patterns from training data.
• Another agent writes the code.
• Another agent checks the code — does this function preserve the right symmetries? Do the units balance? Does the answer match known limits?
• Another agent tests the code against reality — experimental measurements, known benchmarks, physical laws.

Think of it like a well-run engineering team, except every member is an AI, and they can work on a thousand files in parallel without getting tired or distracted.

Why we start with physics

If our goal is to build AI that writes trustworthy code for cars, banks, and hospitals, why do we start with nuclear physics?

Because physics gives us something no other field does: an objective judge.

When an AI writes code that simulates how an atomic nucleus behaves, we can check the answer against nature. Not against another piece of software. Not against a human opinion. Against the actual measurements that physicists have made in laboratories over the past century. The universe does not grade on a curve.

This matters because the hardest part of building trustworthy AI is not making it write code. It is knowing whether the code is right. In most software domains, “right” is fuzzy — does the user like it? Does it pass the tests someone wrote? In physics, “right” is a number that either matches the measurement or does not.

That clarity is a gift. It lets us build verification methods — ways to automatically check whether AI-generated code is correct — and actually measure how well they work. Once those methods are proven in physics, they travel. Dimensional analysis works in physics, but the same principle (do the units of this calculation make sense?) applies to financial models, engineering simulations, and drug dosage calculations.

We do not start with physics because it is the only thing that matters. We start with physics because it is the only place where we can measure, with certainty, whether our AI is telling the truth.

The road from 10,000 to 1,000,000,000

Going from 10,000 lines to one billion is not about making the AI “bigger.” A model with more parameters will not automatically write more correct code. The challenge is architectural — how do you organize an AI system so that correctness scales?

Here is an analogy. A single brilliant architect can design a beautiful house. But you cannot build a skyscraper by asking that same architect to design a really, really big house. Skyscrapers need structural engineering, load calculations, safety systems, and coordination across dozens of specialized teams. The jump from house to skyscraper is not about being better at houses. It is about building a different kind of system.

The same is true for AI code. To go from 10,000 correct lines to a billion, we need:

• Verification at every step. Not checking the code once at the end, but building correctness guarantees into every stage — the way a building inspector checks the foundation before the walls go up.
• Coordination across agents. When one AI agent writes a function and another agent uses it, they need to agree on exactly what that function does — not approximately, not usually, but exactly.
• Memory that scales. A human programmer working on a million-line codebase does not remember every line. They know where to look. AI complexes need the same ability — structured knowledge about what the code does, organized so they can find what they need without reading everything.
• Graceful handling of mistakes. In a billion lines, there will be errors. The system must detect them early, isolate them, and fix them — the same way your immune system finds and destroys threats without shutting down your whole body.

This is what we are building. Not a smarter chatbot. A system of systems — an AI complex — where correctness is a property of the whole, not a hope pinned on any single part.

What this means for you

If you are a physicist, this means AI that can write simulation code you can actually trust — code that has been verified against the laws of nature before it ever reaches your screen.

If you are an engineer, this means AI that can help build and maintain safety-critical systems at a scale no human team can manage alone.

If you are a doctor, a banker, a pilot, or simply someone who uses software every day, this means a future where the code behind the systems you depend on is more reliable than it has ever been — because it was not just written by AI, but verified by AI, at a depth and scale that human review alone cannot achieve.

And if you are someone who simply cares about whether AI can be trusted with serious work — not just writing emails and generating images, but doing things where lives and livelihoods are on the line — then this is the question we are trying to answer.

Today, AI writes 10,000 lines that must be right. We are building toward a billion. The gap is enormous. So is the opportunity.

We are just getting started.