I’ve often reflected on how AI will change software development, and on what happens when reverse engineering — “everything is open source if you can reverse engineer it” — or clean-room reverse engineering, and porting a program from platform A to platform B, become essentially automatic processes.

Personally, this is a capability that would impress me quite a bit. I’m curious to know: if you let something like Astra 6 or Fable run with $10 million worth of tokens, how close could we get to a successful implementation and performance — say, porting the Adobe suite to Linux, or even FreeBSD, or whatever operating system you happen to use? Personally, I think this would be a very interesting benchmark...

And this is where I’d like to get to: why Linux or FreeBSD? If we had this ability to port software, then in many respects the platform, as we know it, would become irrelevant, just like the programs that run on it. The code becomes irrelevant.

You could simply say:

“Create an operating system from scratch, absolutely optimized for my CPU, GPU, and so on, that works and looks exactly like Windows XP — in terms of its interface and workflow. Not only that: take all the dozens of programs I use on Windows XP, clean-room reverse engineer them, and recreate their workflows and behavior, producing versions of those programs for this new platform that you just created specifically for me.”

In this scenario, the code itself doesn’t really matter. The code is almost beside the point. What matters is the specification of how the program is supposed to behave: “If I enter command X, the program does Y. If I click here, a pop-up appears. If I drag this object there, it behaves like this.” And so on. What you ultimately need is not the original code, but a sufficiently complete description of the behavior the code is meant to produce.

Which, incidentally, is the challenge users face when migrating between platforms. The challenge is rarely “Oh, it’s impossible to find a program that performs function X on platform Y,” but rather: “It’s impossible to find a program that performs function X on platform Y in the same way that it performed that function X on platform Z,” not that unlike the concept of technical debt.

In practice, what we would be witnessing is a separation, a divorce between “code” and the “behavior” that the software is supposed to exhibit. People talk a lot about “software as a service”; well, I like to think of this as “software as behavior.” Your “real OS” would be the LLM equivalent embedded into the operating system, functioning as a kind of “program capable of creating programs.” That’s where things get really interesting. It seems that the only piece of software that would truly matter would be the AI running on top of the system.

Acting as a kind of universal translation layer between intent/behavior and implementation. In that sense, perhaps the true “operating system” is less the kernel and more this ability to turn specifications into executable programs.

I’ve been paying attention to these so-called “Agentic OSs,” such as Omarchy, and it seems to me to be heading in the right direction toward what the future of computing might look like. Because, assuming the model is good enough, it could create or port whatever software you wanted. In this scenario, the operating system ceases to be exactly the platform on which programs are developed and instead becomes almost an accessory to the AI.

And at the end of the day, “implementation documentation becomes the source code” — and you, theoretically, setting aside the problem of resources, can always produce that documentation; there has always been enough information to reconstruct a large part of the idea behind the original concept.

--------------------

Anyway, sorry for this long text, probably nobody will read XD But I'm really fascinating by all theses possibilities. I would love to hear your takes.