Eric S. Raymond, one of the co-founders of the open-source movement, has formulated a pointed thesis: closed-source software is effectively finished thanks to AI-assisted reverse engineering. What this means is the path from the delivered binary program back to readable source code – a process that until now required specialised knowledge, a great deal of time and often laborious manual work.
The report itself is brief, the debate behind it is not. Because it touches on an assumption on which many business models and also some internal IT strategies are based: that undisclosed source code constitutes a practical form of protection.
What it is technically about
Compiled software exists as machine code. Variable names, comments and a large part of the original structure are lost in the process. Decompilers can indeed produce something resembling source code from this code, but the result is traditionally difficult to read and can only be understood with considerable effort.
This is precisely where Raymond's argument comes in: language models are good at recognising patterns, naming structures and turning unreadable code into an understandable form. If this reconstruction succeeds reliably and at high speed, the practical hurdle that has hitherto stood between a binary and its inner workings drops significantly.
Protection through obfuscation was never security
In security discussions, the principle has long held that keeping code secret is no substitute for robust protection mechanisms. This insight is not new, but more powerful analysis tools are making it more immediately tangible.
In practice, this above all means: anyone who stores access credentials, API keys, licence logic or business rules in compiled code and relies on nobody finding them there is working with an assumption that is becoming increasingly fragile. Security must come from architecture, access management, server-side validation and encryption – not from the hope of unreadability.
Technically possible is not the same as legally permissible
One important distinction tends to get lost in such debates: whether code can be analysed is a technical question. Whether one is allowed to do so is a contractual and copyright question. Licence terms, usage contracts and statutory regulations remain in place even when the technical effort decreases.
For companies, this means two things. First, one's own legal position should be known before third-party software is analysed. Second – and more relevant in practice – one should not rely on third parties adhering exclusively to rules that are difficult to enforce.
The underestimated side effect: legacy systems
The more exciting side of the development may not lie in protection at all, but in maintenance. In many small and medium-sized enterprises, applications are running whose source code is no longer accessible: the service provider no longer exists, the repository has been lost, the documentation is limited to the knowledge of a few individuals.
Such systems are often still in use today only because replacing them is expensive and nobody knows exactly what the software does in detail. If a readable, commented image of the logic can be obtained from a binary, this noticeably changes the starting position for migrations. A black box becomes an analysable artefact.
Caution is still advisable nonetheless: reconstructed source code is not automatically correct, complete or maintainable. It is an interpretation. Any new development derived from it requires tests, specialist review and proper acceptance by the business department.
What this means for licence and product models
Anyone who sells software as a product has rarely built their business model on secrecy alone. The value usually lies in operation, support, further development, data integration and reliability. These very components gain in importance when mere code ownership offers less protection.
For companies commissioning custom software, the negotiating perspective also shifts as a result. Questions about source code release, documentation obligations, exit scenarios and code escrow belong in the contract – regardless of how good analysis tools have become. Anyone who already owns their code does not need to have it reconstructed.
Assessing the thesis
Raymond's statement is pointedly formulated, and it stands for a position, not for a measured finding. How reliably AI-assisted decompilation actually works across the board depends on the programming language, compiler, level of optimisation and protective measures. Between a well-reconstructed utility program and a fully understood, complex enterprise application there remains a considerable difference.
The direction is nevertheless plausible: the effort required for code analysis is falling, and what becomes cheaper happens more often. Strategies that rely on high analysis effort on the part of third parties thus lose viability.
Concrete implications
- Check whether security-relevant logic or secrets lie exclusively in the client or in the compiled code.
- Anchor licence and access checks on the server side instead of in the delivered program.
- For existing contracts, clarify who owns the source code, build processes and documentation.
- Inventory legacy systems: where is the source code missing, and what risk arises from that today?
- Consider openness as an option – not out of ideology, but because traceability makes maintenance easier.
What this means for web and software projects
For ongoing projects, the focus shifts from secrecy towards architecture, documentation and contractual clarity.
Anyone commissioning a custom solution today should make source code access and exit capability just as much a matter of course as functional scope and deadlines.And anyone running a legacy system without source code now has an additional, technically realistic way to resolve this risk in a plannable manner.
Sources
- Decompilation by AI: Why closed source is finished according to Raymond — heise developer News