ReadMultiplex.com: The Last Program: How AI Is Replacing Every App You Use.
47 minAudio
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! A person who needed a photograph adjusted once opened a program, selected tools from a menu, and saved a file. The same person who needed a column of figures totaled once launched a spreadsheet and entered formulas. Both actions delivered the result the person already knew how to describe. The program existed only because the computer required the description to be translated into a sequence of operations it could execute. The binary was never the work. It was the tax the machine charged for refusing ordinary language. That translation is no longer required for most work. A model that observes how a closed program behaves, compares the results against published file formats and test cases, and emits equivalent operations in another language can reconstruct the program. In early October 2026 Brandon Thomas of ArtCraft directed Claude Opus 5.5 agents to produce clean-room reimplementations of seven Adobe applications in Rust. The repositories appeared between 30 September and 1 October. PhotoCraft, the Photoshop equivalent, reached roughly 45,000 GitHub stars within ten days; the seven repositories together exceeded 86,000 by 11 October. The majority of commits carry a co-author line for the model. The project states that it studied behavior and public specifications only and did not copy proprietary code. Read more at: ReadMultiplex.com Support this work by buying us a coffee: https://ko-fi.com/brianroemmele
Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.
Transcript
From the show. Tap a time to play from there.
Imagine it is the year 2036. You sit down at your desk to do some work, and you turn on your machine, but, and this is the crazy part, there is no Windows logo that greets you. Right, there's no Apple menu bar at the top of the screen either. Exactly. You don't have Microsoft Word or Photoshop or Excel installed on your hard drive. None of it. In fact, if you tried to explain the concept of, you know, installing an application to a younger colleague, they would look at you the same way we currently look at someone, feeding a stack of cardboard punch cards into a room
-sized mainframe. Like you're an absolute dinosaur. Yeah, exactly. So welcome to the deep dive. Today, we are exploring this just breathtaking shift in human -computer interaction. And we're guided by a phenomenal source document today titled The Last Program. It's a fascinating read. It really is. Truly. And the core thesis we are unpacking today is going to fundamentally alter how you view the screen in front of you. I mean, the claim is that Every piece of software you currently pay for, every application you've spent
years learning to navigate is basically nothing but a temporary tax. A tax you have been paying simply because machines were previously too stubborn to understand ordinary human language. Right. And before we get into the mechanics of all this, I want to make something very clear to you, the listener. The reason we have the privilege of exploring this bleeding edge analysis today is entirely due to the Read Multiplex podcast and the phenomenal work of Brian Romilly. Absolutely. The last program is his source material. It's
his vision and his synthesis. It is. So if you value understanding the digital future before it actually arrives, you know, if these deep dives give you an edge in your industry or just satisfy your intense curiosity, you really need to support Brian. You really do. Please become a member of his community or at the very least just buy him a coffee. Your support is the engine that keeps these paradigm shifting explorations going. So go support Brian Romilly and his amazing work. It's definitely worth it because the depth of analysis in this document warrants that support.
I mean, it doesn't just predict a trend. It outlines a complete structural collapse and rebirth of the software industry. And it grounds it in very specific technological mechanisms, right? Exactly. It upends 50 years of software engineering philosophy. We are charting a course from a highly specific explosive catalyst event in October 2026, mapping the economic and legal fallout, and finally arriving at that post -app reality you just described in 2036. So let's look at that mechanism that
sets this entire collapse in motion. The document pinpoints early October 2026. A developer named Brandon Thomas, working at a company called Artcraft, basically initiates what we can only call a shockwave. A total shockwave in the developer community. Right. He directs a suite of Claude Opus 5 .5 AI agents to create clean room re -implementations of seven flagship Adobe applications. And he tasks the AI with writing these new applications entirely in the Rust programming language. And the timeline here is the first major indicator
of the paradigm shift. I mean, the repositories for these clones appeared on GitHub between September 30th and October 1st. Two days. Two days. Functionality that originally required decades of iteration. Thousands of specialized human engineers. It was replicated over a single weekend. It's just wild to think about. And the developer community's reaction was instantaneous. The document notes that the Photoshop equivalent, which they dubbed Photocraft, hit 45 ,000 GitHub stars in 10 days. Which is astronomical for a new repo. Oh, totally.
And the entire suite exceeded 86 ,000 stars by October 11th. But the detail that really signals the inflection point, the thing that blew my mind. is that the majority of the commits, the actual lines of code being submitted to the project, carried a co -author line crediting the AI model. Yeah, the human was just the director. The AI was the primary builder. Which forces us to really examine the actual process used here. Because they didn't just steal the code, did they? Nope, not at all. The project explicitly stated they
did not copy proprietary code. They utilized a method of reverse engineering by observation. Okay, let's pause and draw a hard line here between observation and decompilation. Because this is where the legal and technical arguments usually get, you know, really tangled up. Right. It's an important distinction. Historically, if you wanted to clone a piece of software, you might try decompilation. You take the compiled binary file, that executable black box that runs on your machine, and you run it through a decompiler to spit out something resembling the original
source code. But decompilation is famously flawed. And legally hazardous, too. Right. Because the compiler strips out all the human intent. Exactly. The variable names, the comments, the elegant logic structures, all of that is optimized away into raw machine code. It's just ones and zeros at that point. It's not just unbaking a cake. It's more like trying to reconstruct a highly complex multilingual novel by only looking at a spreadsheet that details how many times each letter of the alphabet was used. That is a great
analogy. You know, you have the raw materials, but the narrative flow, the grammar, the human intent behind the story was completely shredded by the compiler. It's a mess. And looking at that mess often violates end -user license agreements anyway. And that is precisely why the methodology outlined in the last program bypasses the binary entirely. The AI agents didn't even attempt to unpack Adobe's compiled code. They just observed the software as a user would, but at the speed and scale of computation. Let's get into the
technical weeds here of how a text -based or even a multimodal LLM actually observes complex visual software like a photo editor. I mean, how does an AI look at a screen and write Rust code to match it? Well, it requires a synthesis of a few different capabilities. First, the AI leverages computer vision to analyze the graphical user interface. It literally maps the visual state of the application. Like it sees where the buttons and sliders are. Right. Then it interacts with the program. So it feeds it a specific image
file, applies, let's say, a Gaussian blur filter with a radius of five pixels. And then it observes the new visual state. But crucially, it doesn't just look at the screen. It analyzes the underlying file formats. Ah, right. Because the specifications for formats like PSD or PDF, those are publicly documented. Anyone can read how a PSD file is structured. Exactly. So the AI agent. generates an input file, applies a function in the target software, and then mathematically compares the output file against that public specification.
So it's looking at the math? Yes. Once it understands the exact mathematical transformation that occurred, say, a specific matrix multiplication applied to the RGB values of a pixel array, it proposes a piece of Rust code to replicate that exact math. And then it checks its own work, right? It compiles its proposed Rust code, runs the exact same input file through it, and compares its output to Adobe's output. Perfectly said. And if the hexadecimal values of the resulting files don't match, it iterates. It tweaks the
Rust code and tries again. Millions of times over. Millions of times. It is an automated high -speed loop of hypothesis, execution, evaluation, and refinement. And the choice of Rust here. as highlighted in the document, is not accidental at all. Why Rust specifically? Well, Rust offers memory safety guarantees and fearless concurrency. That means the resulting application is incredibly fast and less prone to the kind of legacy memory leaks that plague older C++ code bases. So it's
actually building a better foundation. Exactly. The AI isn't just copying the function. It's often writing structurally superior, more modern code to execute that function. Which naturally leads to the question of viability because, you know, 45 ,000 GitHub stars usually indicates massive hype, but hype doesn't equal a production ready tool. Very true. If I am a professional art director working at an agency and I drop a hundred layer PSD file onto my desk, is Photocraft actually going to handle that on day 10? The source document is actually highly objective
about this limitation. It clearly states that while Photocraft achieved high coverage of standard menu commands, and it demonstrated solid round -trip success on test PSD files, meaning it could open the file, modify it, and save it without corrupting the data structure, its internal readiness for heavy, professional daily work was still lower than the original. Right, the edge cases. The undocumented legacy features, the highly specific color profile management behaviors that a professional just relies on without even thinking about them. The clone is going to stumble there,
isn't it? It will stumble initially, yes. But the document argues that focusing on the immediate gap misses the historical magnitude of the event. The gap between the clone and the original is just a matter of time and iteration. It's not a fundamental barrier. The dam has broken. Exactly. The critical takeaway is that the scarcity of the binary has been broken. The scarcity of the binary. Let's dig into that, because for 50 years, the software industry's entire economic model has been predicated on the assumption that writing complex software is impossibly hard, highly expensive,
and requires a massive organization. A huge moat. Right. The compiled binary was this scarce, highly valuable artifact. If you wanted the capability to edit layers in a photograph, you had to rent the binary from the organization that spent $100 million building it. And the October 2026 event demonstrates that the capability to perform those complex operations is no longer tied to the proprietary binary. The operations can be systematically extracted and perfectly replicated by an automated
observer in a matter of hours. The moat has completely evaporated. So if the ability to composite images or sort massive databases or compile code is no longer a scarce resource, what happens to the value of software? I mean, the text introduces this concept of the surviving scarcity. If code is infinitely and instantly reproducible, what is the bottleneck? The bottleneck reverts to human judgment. Human judgment. Yes. The document articulates this beautifully by examining what an AI generated clone actually lacks. We have
an open source clone that can perfectly composite 20 layers of high resolution imagery. It understands the math of a drop shadow and the physics of light rendering perfectly. Better than a human, probably. Right. But the AI agent possesses no concept of why the composite is being constructed. It doesn't know if the resulting image is meant to evoke nostalgia for a marketing campaign or if it's meant to accurately document a journalistic event without misleading the public. It cannot determine if the output advances your underlying purpose. The AI can provide the mechanism, but
only the human can provide the intent and the final evaluation of success. That's a profound shift. It is. And this brings us to a profound philosophical reframing in the text. It posits that software... as we have historically understood it, was merely a translation layer. A translator between human intent and machine limitation. Think about the evolution of human -computer interaction. The machine only understands microscopic electrical state changes, zeros and ones. To
get the machine to do work, humans had to learn its language. Right, we started with punch cards. Then we moved to command -line interfaces, learning highly rigid syntax. Then we invented graphical user interfaces, replacing typed commands with drop -down menus and icons. But even a drop -down menu is basically just a dictionary. When you launch a massive spreadsheet application, you have a core intent in your mind. You're thinking, tell me if our Q3 marketing spend actually resulted in a higher customer retention rate, and flag any regions that deviated from the trend. That
is your intent. But the computer couldn't accept that intent. It refused ordinary language. So you, the human, had to act as the translator. Exactly. You had to launch the spreadsheet. You had to know which buttons to click to import the CSV data. You had to manually write the syntax for VLOOKUPs and pivot tables. Yeah. You had to map the cells, apply conditional formatting, and manually construct the graph. You had to break down your high -level intent into 50 micro -operations that the software's interface could actually understand. And we became so accustomed
to this translation work that we started to conflate it with the actual job. We put proficient in Excel or Adobe Creative Suite Master on our resumes, as if navigating the labyrinth of a software interface was the actual valuable skill. Wow. We took pride in being mechanics when we really just wanted to be drivers. We memorized the transmission ratios just so we could go to the grocery store. That's it exactly. The source document argues that navigating the software was never the actual work. The work was extracting the anomalous data
to make the business decision. Right. The work was adjusting the contrast so the photograph communicated the right emotion. The software was just the hurdle you had to clear to execute your judgment. So when the AI agents demonstrate they can reconstruct the software's capabilities on demand, they are essentially taking over the job of translation. You just state the intent in ordinary language and the AI agent automatically maps that intent to the necessary computational operations. Which completely eliminates the need for the permanent translator. You no longer need
the massive bloated software application sitting on your hard drive waiting for you to click its icons. Okay, this moves us into the timeline the document sets for 2028. This is the era of the program as a temporary object. A massive conceptual leap. The text suggests that within two years of the Catalyst event, most commercial software whose behavior can be observed will exist as open implementations. But it goes a step further, doesn't it? It says we won't just replace proprietary apps with open source apps.
We will stop using apps entirely. Yes. The concept of the installed application begins to dissolve. When you state a complex job to your system, let's say, produce a layout fitting these images with space for a caption. Or... Match the lighting of this reference video clip to these three raw clips. The system does not launch a named program. So walk me through the actual computer science of this transient environment, because I'm trying to picture this on my machine. How does an operating system handle on -the -fly computation without
a permanent application structure? It relies on an evolution of containerization and modular architecture. It's likely utilizing technologies akin to WebAssembly. or highly optimized sandboxed environments. Okay. So when you state your intent, a local AI routing model translates that intent into a directed acyclic graph of mathematical operations. It pulls the necessary open source operational libraries, say an image parsing library in a matrix transformation library. And then
it compiles a highly specific lightweight executable just for this single request. It compiles it right then and there. Yes. It executes the code, renders the video frame, hands the result back to the display layer, and then the executable is immediately purged for memory. The computation exists exclusively for the duration of the request. Exactly. No background process is left running, no registry key is modified, no massive application suite consuming your system's resources while it's just sitting idle. Okay, I have to push
back hard on the physics of this, though, because... The latency of compiling a custom program from scratch every single time I want to crop an image or sort a list, it just sounds absurd. I know, it sounds counterintuitive. We are talking about replacing highly optimized, pre -compiled C++ binaries with AI -generated, just -in -time code execution. Isn't this going to be painfully slow? And won't it require massive, expensive cloud computing power? I mean, if I have to wait five seconds for an AI to write a script just to turn my text bold, the entire paradigm collapses.
That is the natural skepticism, absolutely. But it stems from a misunderstanding of what the AI is actually generating. The AI is not writing a new image rendering engine from scratch every time you ask for a crop. Ah, okay. Clarify that distinction because it's critical. The heavy lifting, the actual processing of pixels, or the cryptographic hashing of a file, or the complex sorting algorithms, those remain pre -compiled. highly optimized mathematical libraries stored locally on your machine. So the foundation is already there. Exactly. What the AI generates
on the fly is merely the glue code. It writes the tiny script that routes your specific data through those pre -existing hyper -fast libraries based on your ordinary language request. Oh, so it's like a highly intelligent API caller. It's not reinventing the wheel. It's just instantly writing the code that connects the steering wheel to the axle based on where I want to turn. That is the... perfect way to look at it. Generating 50 lines of glue code in Rust or Python takes milliseconds for a local model. The execution
of the underlying mathematical library is just as fast as it would be if Adobe had called it. Okay, that makes sense. Which brings us to arguably the most controversial and fascinating claim in the entire document, the hardware renaissance. This is where the economics really get turned upside down. You mentioned local models just now. The text insists that this revolution doesn't require a massive server farm. It claims this transient computation happens locally, right on the user's desk, using surprisingly old hardware. The document paints a very specific scenario.
It argues that a standard Linux machine from 2015 or 2018, something sitting under a desk collecting dust because it can no longer run the latest bloated commercial software, suddenly becomes a highly capable primary computer again. I need to scrutinize this. Because the hardware requirements for AI right now are astronomical. The text explicitly claims that 8 to 16 gigabytes of RAM is enough to run these models. Yes, it does. But anyone who has tried to run a modern large language model knows that you need massive
amounts of VRAM. A 70 billion parameter model cannot physically fit into 8 gigs of system RAM. Furthermore, an old 2015 motherboard is running PCIe Gen 3, maybe DDR3 memory. The memory bandwidth is just a fraction of what a modern unified architecture provides. You're not wrong about the specs. You'd be waiting minutes for a massive model just to load into memory, let alone generate tokens. So how does the document justify this claim? The justification relies on the rapid divergence
between generalized LLMs, large language models, and specialized SLMs, which are small language models. Okay, small language models. You're absolutely right. that an omniscient chatbot that has memorized the entire internet requires massive VRAM and memory bandwidth. But the agent running on this 2015 Linux machine is not a generalized chatbot. It doesn't need to know the history of the Roman Empire or how to write a sonnet in the style of Shakespeare. It only needs to know software syntax and file structures. Precisely. We are
talking about highly quantized, task -specific models. A 4 -bit quantized model trained exclusively on routing ordinary language to standard programming libraries might only be 2 or 3 billion parameters. It requires perhaps 1 .5 to 2 gigabytes of RAM. Wow. So it fits easily into the memory footprint of an old ThinkPad? Easily. And because its output is constrained to short bursts of structural glue code, the token generation speed, even on a slower CPU with DDR3 memory, is measured in
milliseconds. The text argues that the operating system only needs to provide file access, process management, and network exposure. A stable Linux kernel from a decade ago does this flawlessly. Let's ground this in reality then. What does this 2015 machine actually do for the user in this new paradigm? The source provides some great, highly specific daily use cases. Consider the... tedious administrative work that consumes hours of human capital right now. The document gives
the example of saying to the system, extract the invoice numbers from this folder of PDFs and place them in a table that matches the format we used last month. Historically, that requires opening a bloated PDF reader, manually copying data, opening a massive spreadsheet application, pasting, formatting. It takes forever. With a local agent, the model instantly generates a script utilizing an open source PDF parsing library and a CSV writing library. It executes the extraction, formats the data based on its observation of your historical files, and presents the table.
Boom. Or a hardware monitoring scenario, right? The text mentions saying, monitor the temperature of these attached external sensors and send me an alert only if the reading stays outside the 70 degree range for more than 10 minutes. Instead of buying and installing an expensive proprietary dashboard application that consumes four gigabytes of RAM just to idle in the background, the agent writes a tiny, highly efficient background daemon in Rust. It compiles it, sets it to run, and the system load is practically zero. The machine
is doing the actual calculation locally again, rather than acting as a dumb, thin client requesting computation from a cloud service that charges a $30 monthly subscription. absolute catastrophe for the current hardware and software economic models. I mean, the entire revenue structure of the hardware industry relies on planned obsolescence driven by software bloat. The upgrade treadmill. We don't buy a new laptop every three years because the silicon degraded. We buy it because the new operating system update and the new version of
our daily software suite requires twice as much RAM just to maintain the same perceived speed we had three years ago. But if the software is generated locally. Perfectly tailored to the constraints of the hardware's existing specifications, using unbloated, open implementations, that forced replacement cycle shatters. A machine that continues to run reliably becomes an enduring asset, not a depreciating liability. You might add a cheap neural processing unit via USB or something, but you don't throw away the motherboard and the chassis. Which brings us to the inevitable
counterattack. Right. Because the multi -trillion dollar market caps of companies like Apple, Microsoft, and Adobe are predicated on you continuously buying hardware or paying monthly subscriptions. They are not going to passively watch as local open implementations render their products obsolete. The transition from proprietary binaries to transient computation is going to trigger the most brutal legal war in the history of technology. And the source document pinpoints the opening maneuver of this war. It specifically highlights a change
in Adobe's general terms of use, citing Section 17 going into effect in October 2025. Section 17. Yes. Section 17 represents a desperate attempt to plug the dam. For decades, software licenses have explicitly banned decompilation and reverse engineering of the source code. But Section 17 extends the ban to the act of observation itself. Wait, observation. Exactly. I'm just looking at it. Exactly. It explicitly prohibits tracking, monitoring, or observing the behavior, inputs,
or outputs of the running application in order to rebuild its functions or train a machine learning model. They saw the art craft scenario coming. They realized that if an AI can just watch the screen and figure out the math, the binary is indefensible. So they tried to make the act of watching illegal. And the corporate legal arsenal is immense. They will enforce these subscription contracts against any user or developer they suspect of utilizing observation agents. They will deploy thousands of unexpired utility patents covering specific image processing algorithms
or user interface paradigms. They'll throw everything at it. They will leverage trade dress infringement, arguing that if an open source clone visually mimics the layout of their tools, it causes market confusion. But the critical question is... Will any of this actually stop the paradigm shift? The document argues forcefully that the corporate defense will fail. It roots this failure in a foundational principle of intellectual property law. Let's unpack the legal realities here. Why does a ban on observation ultimately collapse?
Because it collides directly with the fundamental distinction in copyright law between expression and operation. Expression versus operation. Yes. Copyright law protects the specific expression of an idea, but it explicitly does not protect the idea itself, nor does it protect the operation, procedure, or system used to achieve a result. Let's use an analogy here to make that concrete, because legal theory can get dry. Consider a famous cookbook. A perfect example. A chef can
copyright the specific way they wrote the story about their grandmother's pasta. They can copyright the photography, the layout of the page, the specific adjectives used in the instructions. That is their expression. But they cannot copyright the operation of boiling water for 10 minutes to cook dried pasta. Exactly. If another chef reads the book, realizes that boiling water cooks pasta, and writes their own completely unique instructions detailing how to boil water, there is no copyright infringement. The first chef
doesn't own the chemical reaction of heat and starch. So applying this to software, Adobe owns the copyright to the specific millions of lines of C++ code they wrote to build their photo editor. That is their expression. Right. But they do not own the mathematical concept of applying a Gaussian blur to a grid of pixels. They do not own the operation of, you know, making an image darker when a slider is moved left. And courts have historically defended this distinction rigorously, particularly regarding interoperability. There is a famous precedent here that the document's
logic echoes perfectly. The story of Compaq cloning the IBM PC BIOS in 1982. Yes, the clean room design precedent. This is crucial history. IBM had a monopoly on the PC market because they owned the proprietary BIOS, the basic input output system that allowed the hardware to talk to the software. And if you wanted to build a computer that could run IBM software, you had to have their BIOS. But they wouldn't sell it to you. So Compact used a cleanroom approach. They set up two teams of engineers. Team A read the copyrighted
IBM source code and documented exactly what it did, its inputs, its outputs, its timing. They wrote a purely functional specification manual. But Team A was legally contaminated. They had seen the copyrighted expression. Right. So Team B enters the picture. Exactly. Team B had never seen the IBM code. They were locked in a room with only the functional specification manual written by Team A. Team B wrote a brand new BIOS from scratch that performed the exact same operations.
When IBM sued, the courts ruled in favor of Compaq. Team B only copied the function, the operation, which is not copyrightable. Fast forward to 2026. The AI agent acts as Team B. Precisely. The public documentation and the visual observation of the software act as the specification manual. The AI has never seen Adobe source code. It only observes the function and writes a completely new expression in Rust to achieve the same operation. The legal precedent strongly protects this. And regarding Adobe's new contractual ban on watching
the software, the document points out the utter practical impossibility of enforcing it. It's totally unenforceable. I mean... How does a court distinguish between an AI agent rapidly observing a program's behavior and a human user rapidly clicking through a program while recording their screen for a YouTube tutorial? It cannot. The distinction collapses entirely when you consider that the AI can simply ingest the thousands of public tutorials, help manuals, and public API documentations that the vendor themselves published.
If the operation can be described in ordinary human language, That description can be handed to a generative model that has never touched the proprietary software, and that model can write the code. It's unenforceable. It's like a restaurant banning you from remembering what the food tasted like so you don't try to cook it at home. That's a great way to put it. And this brings us to the Napster parallel. The document uses the music industry's crisis at the turn of the century to crystallize the software industry's impending doom. Let's really dig into the mechanics of that analogy. For the entire 20th century,
The music industry's business model was tied to physical scarcity. They believed they were in the business of manufacturing and distributing plastic discs, vinyl, cassettes, CDs. The physical object was the scarce container for the value, which was the audio recording itself. Right. Before widespread broadband internet, if you wanted to listen to a specific album on demand, buying the physical CD was the only practical method. But then digital compression formats like MP3 and peer -to -peer networks like Napster
emerged. Suddenly, the audio recording could be perfectly replicated and instantly transmitted without the need for the plastic disc at all. The value is completely decoupled from the physical container. And the music industry's reaction was identical to what the tech industry will do. Total legal panic. Look at the A &M Records v. Napster case. The record label sued the platform. They sued individual college students. They spent millions developing digital rights management, trying to create CDs that couldn't be ripped to a computer. And it was entirely futile. They
successfully shut down Napster, but the peer -to -peer genie was out of the bottle. BitTorrent, LimeWire, Kazaa immediately replaced it. The fundamental technological reality had shifted. Data routing was vastly more efficient than physical distribution. And the author of the last program argues that the software industry is making the exact same category error today. Tech conglomerates believe that the compiled binary file is the indispensable container of value. They believe they are selling access to that specific heavy
proprietary file. But the 2026 ArtCraft event proves that the operations, the actual mathematical transformations the user desires, can be perfectly extracted and transmitted without the proprietary binary container. Observation and AI generation are the MP3 compression of the software world. While the legal nuances differ, you know, music copyright protects the fixed audio performance, whereas software copyright protects the written code, the practical outcome is identical. Adobe
or Microsoft might win a lawsuit against one specific AI developer. They might force a GitHub repository to be taken down using a DMCA notice. But they cannot reinstate the fundamental condition of scarcity. Because once the knowledge of how to efficiently sequence an operation is generated and shared as open source code, it propagates instantly. You cannot sue math. out of existence. You cannot sue math out of existence. I love that. And once that open source code is out in the wild, the document predicts an acceleration
that traditional software vendors simply cannot match. Let's move into section six, the acceleration of open implementations. Historically, maintaining an open source project was bottlenecked by human labor. If you found a bug in an open source photo editor, you had to be a skilled C++ developer to understand the code base, write a fix, and submit a pull request. Then the maintainers had to manually review your code, test it, and approve it. It was a system filled with friction. But when AI agents enter the workflow, that friction
drops to zero. The text describes a scenario where any user, regardless of their coding ability, can drive the evolution of the software. Like if an accountant using an open source data sorting tool notices a calculation error in a specific edge case, they don't need to write code. Not at all. They simply describe the error in ordinary language to their local AI agent. The tool is failing to account for leap years when calculating the quarterly amortization schedule. Exactly. And the local agent immediately analyzes the
open source code base, identifies the logical flaw, rewrites the specific function in Rust, runs automated tests to ensure it didn't break anything else, and submits the patch to the main repository. The repository becomes an autopoietic system. It heals and evolves constantly. It completely destroys the traditional vendor release schedule. You aren't waiting for a massive corporation to prioritize your bug fix in their Q4 service pack. The community agent fixes it in three minutes. This extreme adaptability also leads to the proliferation
of forks. Because the underlying operations are transparent and modular, communities can instantly branch the software to serve highly niche requirements. The document mentions legacy integration, which is a massive headache for the enterprise world. Currently, migrating a Fortune 500 company from an old proprietary database system to a new one is a multi -year, multi -million dollar nightmare fraught with data loss. But in a world of AI -generated open implementations, migration becomes a trivial mathematical proof. The AI agent can
ingest the public file formats of the legacy software. It generates an open clone. And to prove it works, the enterprise tasks the AI with running 10 ,000 of their most complex legacy files through both the old system and the new clone, confirming byte -for -byte identical outputs. The risk is eliminated. If the outputs match perfectly, the enterprise drops the multi -million dollar licensing contract immediately and switches to the open implementation. They might keep a single license copy on an air -gapped machine for legal compliance, but the daily workflow
shifts entirely. There will also be forks driven by security or hardware constraints. The Department of Defense will utilize agents to strip every line of telemetry or networking code out of an open implementation, creating a mathematically provable air -gapped version. Or a hobbyist will instruct their agent to recompile the implementation to run exclusively on the architecture of a $10 Raspberry Pi. The software bends perfectly to the user's constraints, rather than forcing the user to upgrade their hardware to meet the software's bloat. It is a total inversion of power, and
this acceleration pushes us inevitably toward the final horizon described in the source document, the years 2032 to 2036. This is where we reach the concept that truly breaks the brain, the end of code as a human -facing artifact. Up until this point in the timeline, 2026 to 2030, the AI agents were still writing human -readable programming languages like Rust or Python. They were writing scripts that a developer could theoretically open in a text editor and read. But the document
states that by 2032, this intermediate step is abandoned. Because why generate human -readable code if a human is never going to read it? Exactly. Translating pure mathematical operations into the syntax of a human programming language requires computational overhead. By 2032, the system stops emitting inspectable code. It transitions to maintaining internal, multidimensional representations of operations. So it understands data transformation natively. It understands sorting, filtering, matrix multiplication, and compositing, not as
lines of Python, but as abstract mathematical concepts. When you supply the ordinary language intent and the constraints, the system directly applies the necessary mathematical transformations to the data structure. The distinction between the act of writing software... And the act of using software evaporates completely. Neither activity exists anymore. Which sets the stage for the vivid picture of the year 2036, the post -app workspace. We touched on this in the introduction, but let's explore the granular reality of working
in this environment. The physical devices we use will transition from being hosts for heavy computation to serving purely as interfaces for intent. The screen on your desk or the augmented reality glasses you wear will not display a grid of app icons. There is no start menu. Think about a highly specific, frustrating task we deal with today. You receive a massive data dump from a client in a poorly formatted CSV file. You need to convert it into a nested JSON structure to feed it into a web visualization. Currently, you have to find a sketchy website that offers
CSV to JSON conversion, worry about data privacy, upload it, configure the delimiter settings, download the result, and hope it parsed correctly. In the 2036 workspace, you simply drag the raw data file onto your workspace surface and say to the ambient system, convert this data into a nested JSON format. Group the entries by the region column and strip out any rows where the revenue value is null. And the system simply performs the mathematical transformation instantly. There is no user interface for the conversion tool. There is no application to launch. The
new file just appears. Or consider creative work. You have a raw video file of an interview. You state, Remove the background hum from the audio, color grade the subject to match the lighting tone of this cinematic reference frame, and render a cut that isolates the three moments the subject mentioned the word scarcity. The result is rendered and presented. You didn't open Premiere Pro. You didn't manually tweak a parametric equalizer. You provided the intent and the aesthetic judgment. The system provided the execution. The document uses a phenomenal historical analogy to frame
how bizarre our current reliance on applications will look from the vantage point of 2036. It compares our use of drop -down menus to the use of punch cards in the 1960s. It is the perfect metaphor. In 1965, if you wanted a mainframe to calculate payroll, you couldn't just tell it to do so. You had to sit at a key punch machine and punch physical holes into cardboard cards representing machine code. perfectly sequenced without a single error. You were adapting your human intent to the rigid physical constraints
of the machine's intake mechanism. And today, when we want to remove a blemish from a photograph, we launch a massive application. Navigate to the healing brush tool in a sidebar, adjust the pixel radius slider, and click the mouse on specific coordinates. We are still adapting our human intent to the rigid graphical constraints of the software's intake mechanism. Both punch cards and graphical user interfaces are merely intermediate artifacts. They are necessary compromises required by a system incapable of interpreting natural
language. But once the system can effortlessly parse, route, and execute ordinary language, the intermediate artifact loses its reason to exist. The application vanishes. And this leads us to the absolute defining quote of the last program. It is the thesis statement that synthesizes this entire technological arc. It's a powerful one. The author writes, the binary was never the work. It was the tax the machine charged for refusing ordinary language. It is a devastatingly
accurate assessment. For decades, we believed that buying, installing, learning, and maintaining software applications was an inherent part of digital labor. We spent billions of hours and trillions of dollars servicing the needs of the binary. We paid the tax. We paid it with our time, our cognitive load, and our subscription fees. So if the application is just a tax, and the tax is abolished by AI observation and transient computation, Where does all that human energy and attention go? Well, the attention shifts
entirely back to the refinement of intent and the exercise of judgment. The text explains that the professional of the future is not someone who has memorized the obscure submenus of a design program or the syntax of a database query language. Right. The professional of the future is the person who can most precisely articulate the desired outcome and most rigorously judge the final result. The skill is no longer operating the instrument. The instrument computation becomes invisible and ubiquitous like basic arithmetic. You don't marvel at a calculator's ability to
divide numbers. You simply use the result to balance your budget. Exactly. The human work remains. A financial auditor still needs to identify fraud. An editor still needs to pace a film to evoke tension. An architect still needs to design a structure that inspires awe. The fundamental need for a result in the physical or cultural world hasn't changed. What has changed is that the rigid, proprietary mediator sitting between the human mind and the computational processor has been removed. The judgments were always the
work. That is an incredibly empowering thought to anchor on. Let's zoom out and recap the immense territory we've covered in this deep dive. We began with a catalyst in October 2026. Brandon Thomas and R -Craft demonstrating that AI agents could perfectly reverse engineer complex software capabilities simply by observing inputs and outputs, bypassing the proprietary source code entirely. We analyzed how that breakthrough shatters the historical scarcity of the compiled binary, shifting the remaining value entirely to human judgment
and intent. We explored the mechanics of transient computation. a near future where software does not exist as permanent installations, but as temporary on -demand chains of mathematical operations generated to fulfill a specific request and immediately purged. We debated the profound hardware implications, the realization that highly quantized, localized AI models can run efficiently on older machines, effectively breaking the forced upgrade cycle and transforming aging hardware from a liability
into a durable asset. We examine the inevitable legal warfare, the desperate attempts by tech conglomerates to ban the act of observation, and why those bans will collapse against the foundational copyright distinction between protected expression and unprotected operations, echoing the destruction of the music industry's physical monopoly during the Napster era. We trace the hyper -acceleration of open implementations, where AI -driven continuous integration bypasses traditional vendor release schedules. allowing massive enterprises to frictionlessly migrate
away from legacy systems. And finally, we arrived at the post -app workspace of 2036, a reality where the concept of code is abstracted away entirely, and the human user interacts directly with computation through ordinary language, rendering the traditional application as obsolete as the punch card. It is a rigorous, deeply researched, and frankly thrilling vision of what is to come. And it leaves me with a final provocative thought that extends beyond the immediate scope of the document. Oh, what's that? Well, the author brilliantly
categorized software binaries as a tax we paid because machines couldn't understand our language. If that framework holds true as we enter the era of ordinary language computation, what other massive... billion dollar structures in our society, in our bureaucracies, in our daily lives, are actually just temporary translation taxes waiting to be identified and abolished by observation. Wow. That is the exact critical lens we must apply as we evaluate every digital service we currently believe is indispensable. It absolutely
is. I want to thank you for joining us on this incredible journey today. Before we close, a final reminder, you are listening to the Read Multiplex podcast. The ability to dissect these pivotal shifts, to look 10 years into the future with this level of clarity, is made possible by the pioneering work of Brian Romilly. Do not let this kind of analysis disappear behind a corporate wall. Go to his platform, become a member, or simply buy him a coffee. Your support ensures that these vital, paradigm -shifting deep dives continue to exist. The future is arriving
at an accelerating pace. Understanding the mechanics of that arrival is the only reliable way to navigate it. We started this conversation talking about how much we love the permanence of our digital tools. We like knowing exactly where our apps are installed. But perhaps the greatest technological leap of our lifetime won't be a shiny new application. Perhaps the greatest leap will be the liberating realization that we never needed the application at all. Thanks for joining us on the Deep Dive. We'll catch you next time. Welcome to the multiplex,
where the future comes alive. Past, present, future tech, open up your eyes. Brian Romella leads the way with research deep and true. Technology and history, he connects them all for you. Brian Romella leads the way with research deep and true. Technology and history, he connects them all for you. Ancient sparks to modern code, he traces every threat, go exploration. But humanity
moves on. Love equation for AI. Zero human companies building from the start. Thermodynamic wages earning the key. Secrets we will read. Experiment in publishing real researches and spending every...
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! Every cell in your body has lived its whole life inside a magnetic field. The Earth is a dynamo, and it has been...
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! The 78 RPM Record Hour, Episode 3: From Steel to Hillbilly (Early Country). From steel to hillbilly: Frank Ferera,...
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! The 78 RPM Record Hour, Episode 2: The Knife and the Steel (Hawaiian). The knife of the blues slide guitar and the...
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! Somewhere in your house there is a computer you stopped thinking about. Maybe it is a 2017 laptop in a drawer, its...
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! The 78 RPM Record Hour, Episode 1 (Pilot): Blues. Fourteen original 78 RPM records from 1917 to 1925 that trace...