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.

Hardware-Agnostic Models in vLLM

Slop grenade – demo of Window Management API

Apple Removes iPhone 16 and iPhone 17 from Texture and Grain Support

Show HN: HookDeploy – Webhook infra with mTLS private delivery

Using Local Coding Agents

Tired of Tracking Apps?

Show HN: Droid ASC – An On-Demand Android Decompiler, 41–269x Faster Than JADX

Ask HN: Will software still matter when AI write all our programs?

Extending Scapy for Hardware Reverse Engineering

Show HN: Local Software Factory – running multiple coding agents in parallel

Show HN: Make It Nice

LLM Benchmark for de-identification and synthesis

Law firm paid £200M to support Post Office, while police investigating scandal

Named and Optional Arguments Are Awesome

AI Overviews and the Limits of the Search Safe Harbor

Training a Language Model End-to-End in Rust: An Experience Report

Show HN: Watch Newsletters by AI

Meta testing a 'human concierge' for its new personal AI agent, Muse

SLOPocalypse Survivors

Show HN: Cloud-based email and calendar sync platform and Android app – for sale

OAuth Token Theft Through Microsoft's Front Door

Apple Reference Image Explained Through Anti-Doping

Maynooth university: MU researchers build world-first DNA computer

ComfyUI launches OpenRouter for generative media

Show HN: PicoLM v1.0-rc2 ("Yura Kana"). Run an LLM on Digital Unix

A Startup Wants to Power Data Centers with 'Supercritical' Carbon Dioxide

We open-sourced an event ticketing platform

Functionally Zen

Trump reveals millions of dollars' worth of share deals in big tech and AI

OpenAI nabs key Patreon execs ahead of upcoming announcement

Show HN: Open Code for Jev