A metaphor for what AI is doing to software development.
For as long as we have built software, one thing was fixed: people wrote the code. So producing it was slow and expensive.
Everything we know about building software was learned under that constraint, and shaped by it.
That is no longer fixed. Where AI writes the code, production is much faster and cheaper. Velocity has jumped.
Physics has a word for that: a regime. A regime is a specific range of physical conditions under which a system obeys a particular set of laws. Outside it the system may behave differently. Not because the laws were wrong, but because they were local. Software has run at low velocity for its whole history. This is changing.
Our hard-won rules may no longer hold in the new regime. Which of them still do is an open question.
Two conditions define it. Velocity is low, because people write the code. And what they write, another person can follow.
Everything follows from one economic fact: code is expensive. Both to write and to follow. Throwing it away is a loss. Code reuse. Review gates. Test automation. Continuous delivery. Each aims at the same thing: lowering the cost of change.
Where software is still built that way, these practices work. Raise the velocity and writing stops being expensive. Following it gets more expensive.
One condition changes. AI writes the code, and velocity rises. Take that as given and ask what follows.
The economic fact inverts. Code is cheap, so protecting it stops being the job. What is scarce is understanding and confidence: that we can still follow what was produced, that our intent was followed, and that the result has value to the people using it.
Old practices that worked at low speed fail at high speed. Volume breaks them. What replaces them has to do two things: verify intent and generate insight. Both are bounded in a way generation is not. Intent begins with a person and ends with the same person. Value is answered by use.
White-box testing loses its meaning when the same system writes the code and the tests. Verification needs a source the generator cannot reach: acceptance written from intent, checks it did not author. Otherwise the build goes green and means nothing.
Insight has to arrive at the rate the changes do. Telemetry, progressive release, measurement per change – the practices that answer at volume.
Where velocity is high, that is the work. It follows from one condition changing. A second condition is changing too.
One condition changes. Computation moves onto a quantum machine, and understanding what happens inside gets much harder.
Not by degree. You cannot observe a quantum computation without disturbing it: measuring the intermediate state destroys it, and the state cannot be copied. What comes back is a distribution, not a trace of how it got there. The box is closed and it does not open.
What breaks first are the rules that assume inspection: correctness proved by reading, a bug reproduced by stepping through it, mechanism trusted because it can be seen. Judgement moves to results – run it many times, look at the distribution, decide. At high velocity those practices are advisable. Here they are the only ones there are.
AI writing the code is doing the same thing from the other side. There the code can still be read. It has stopped being worth reading, and much of the industry has already decided as much. One is a choice. The other would not be.
We are already learning to work without seeing inside. Not for quantum reasons – for economic ones. That may turn out to be the preparation.
Physics has properties before it has laws. Mass, velocity, charge – defined, and measurable. Laws are the relationships between them.
The same discipline applies here. Mass. Disposability. Independence. Feedback latency. Velocity. Each can be defined. Most can be measured. Until they are, “everything is changing” is an observation rather than an engineering practice.
That is what this series takes on, one at a time.
The Three Physics of Software was first set out in August 2026.