I have thought about proprietary software lately. The argument for closed source has stopped working. It has not stopped for the reason people usually give.
Closed source never stopped anyone from copying your product. Copyright did that, and copyright still does. Closed source protected the knowledge. It hid the design decisions, the shortcuts, and the years of small fixes for problems you did not expect. A competitor had to work all of that out again and build the product from nothing. That took a long time, and secrecy depended on how long it took.
The time is now short enough to measure. Epoch AI and METR published a test in June called MirrorCode. They gave a model a working program and asked for a copy. The model never saw the source code and could only run the program and watch what happened. The best model rebuilt 56 percent of the 25 programs. One of them was a research toolkit for biologists with dozens of commands, which the authors estimate would take a person two to seventeen weeks.
That is the exact position a competitor is in when your source is closed. They cannot read your code, so they use your product, study it, and build something that behaves the same way. The work used to take weeks or months. That delay was what closed source bought you, and the delay keeps getting shorter.
You may object that the test was easier than real life, and it was. The model got a working copy of the program, the documentation, and a set of tests that told it when the copy was correct. No competitor gets all three. But you hand out the first two yourself, because a product nobody can use is not a product, and nobody gets far without documentation. You keep only the tests.
A program that runs on the customer’s own machine gives away the most. The competitor holds the whole thing. They can run it forever, take it apart, and watch it work, and nobody stops them or even knows. Software written in Java, C sharp, or JavaScript often decompiles into something close to the original code. Desktop software companies lived with all of this for thirty years and did fine, which tells you secrecy was never what they sold.
Hosted software gives away less than that. Your server keeps the database and the machinery that separates thousands of customers, and nobody sees those from outside. It still gives away plenty. Your front end goes to the browser, and that is real source code. Anyone can put a proxy between the browser and your server and record the whole conversation, which shows the field names, the validation rules, the error cases, and every address your own front end calls. You published some of that on purpose. The rest you sent anyway.
A competitor does not want your database. They want their own. They need to know what to build, and you put that on the screen.
So closed source hides how you built the product. Selling the product shows what you built. The second one is the part a competitor needs, and you cannot hide it.
The same failure has a name in security. Kerckhoffs wrote in 1883 that a system must stay safe even when everything about it except the key is public. An attacker studies behavior, and so does a competitor. Neither one needs your source code.
I do not accept the usual claim that open code gets more review. Heartbleed sat in OpenSSL for two years. One person found the xz backdoor because logins were half a second slow.
Proprietary software is not ending. Two different things share one name here. Proprietary means you cannot use, change, or share the software. Closed means you cannot read it. Most software today is hosted, and the customer never held a copy at all.
That difference matters less than people think. Secrecy defended against two threats, and only one of them was piracy. Hosted software was always safe from piracy, because nobody can copy what they never held. It was never safe from a clone, and the clone is the threat that got cheaper. A customer who cannot steal your software can still pay a competitor to rebuild it from the outside.
Small tools that do one thing have the most risk. A small team with good tools can now take on a product that used to need a much larger company. Features alone no longer protect anything.
What remains was never the code. It is the data, the users, the reliability, and a person who answers when the product breaks. The largest advantage is not technical. It is being the default. The vendor is already in the contract, already approved, and already connected to everything else. A small team can match every feature and still lose to that.
The one apparent counterexample follows the same rule. The most valuable software of the decade is also the most closed. The AI labs do not protect source code. They protect model weights, training data, and the money to do it all again. Open models exist and some are good, but they follow rather than lead. Secrecy still works when the hidden thing is expensive to reproduce. Source code is no longer that thing.
So ask what would actually happen if your code leaked tomorrow. For most companies the answer is nothing, and those companies will be fine. Some companies really charged for the fact that you could not read the code. The next few years will be hard for them.