Betting on the Faster Horse

When a breakthrough technology emerges, humanity's first instinct is almost always to use it as a faster horse, forcing the new capability into the architectural constraints of the old mental model. The history of science and technology is characterized by this exact tension.

The true paradigm shift only occurs when someone realizes the new medium allows the old constraints to be abandoned entirely. We are clearly not there yet, so let's first discuss some historical parallels and how they connect to the present moment.

01 Historical Context

Here are some of the most striking historical equivalents where thinkers stopped optimizing the old and fundamentally shifted the regime:

Astronomy: Epicycles vs. Keplerian Ellipses

For nearly a millennium and a half, Western astronomy was held captive by the geocentric model formalized by Claudius Ptolemy in his 2nd-century treatise, the Almagest. Ptolemy assumed as absolute truth that the Earth sat stationary at the center of the universe and that all celestial bodies moved in perfect, divine circles. However, as astronomers meticulously tracked the night sky, they ran into a glaring mechanical contradiction: planets frequently appeared to slow down, stop, and even move backward in what is known as retrograde motion.

To reconcile these messy empirical observations with the rigid dogma of circular perfection, ancient and medieval astronomers were forced to invent epicycles, complex mathematical constructs where a planet revolved in a small circle that itself rode along a larger circular orbit (the deferent).

As observation techniques improved through the late Middle Ages and into the 16th century, the heavens refused to cooperate. To keep the outdated geocentric framework from collapsing under the weight of new data, astronomers were caught in a perpetual cycle of patching the system, stacking epicycles upon epicycles, and adding off-center focal points called equants. The math grew progressively uglier, turning the cosmos into a deeply convoluted, fragile machine engineered solely to preserve a flawed baseline assumption.

The breaking point arrived when visionary thinkers stopped attempting to optimize the existing model and instead abandoned its foundational constraints entirely. In 1543, on his deathbed, Nicolaus Copernicus published De revolutionibus orbium coelestium, a paradigm-shifting work that mathematically repositioned the Sun at the center of the system. While Copernicus drastically simplified the cosmic geometry, he remained stubbornly wedded to the ancient bias for perfect circular motion, meaning his initial heliocentric model still relied on a handful of vestigial epicycles to function.

The true structural revolution was finalized decades later by the German astronomer Johannes Kepler. Utilizing the highly precise, decades-long observational data compiled by Tycho Brahe, Kepler spent years trying to force the orbit of Mars into a circular shape. In 1609, he published Astronomia nova, containing his First Law of Planetary Motion, which boldly discarded circular orbits altogether in favor of ellipses, with the Sun at one focus.

By shifting from rigid circles to fluid, geometry-driven ellipses, Kepler instantly dissolved the hundreds of messy, arbitrary patches that had accumulated over fifteen centuries. The ugly, hard-coded hacks of the Ptolemaic model vanished overnight, replaced by a clean, elegant, and universally applicable mathematical law that fundamentally altered humanity's relationship with reality.

Computing: Babbage's Mechanical Gears vs. Turing's Universal Machine

Throughout the 19th century, mathematics and navigation were plagued by a critical human vulnerability: errors in printed mathematical tables. Navigators, engineers, and actuaries relied on these tables to calculate everything from artillery trajectories to stellar positions, but the tables were computed by human "computers" and were notoriously riddled with transcription and calculation mistakes.

To solve this, the British mathematician Charles Babbage conceived the Analytical Engine in 1837. This ambitious, steam-powered design was a mechanical masterpiece of unprecedented complexity, featuring thousands of interlocking brass gears, cams, levers, and punch cards adapted from the Jacquard loom. Babbage's engine was the absolute pinnacle of mechanical calculation, separating the processing unit (the "mill") from the storage unit (the "store"). Yet, despite its brilliant architecture, it was fundamentally a "faster horse." It remained a physical, rigid manifestation of deterministic mathematics, designed to mechanically grind through numbers by translating human calculation steps into physical gear rotations. It was an incredibly sophisticated attempt to automate a legacy paradigm using the physical means of the Industrial Revolution.

The true paradigm shift did not occur by refining Babbage's brass cogs, but by dissolving the physical machine into pure abstraction. In 1936, the British mathematician Alan Turing published his seminal paper, "On Computable Numbers," introducing the theoretical concept of the Universal Turing Machine. Turing realized that computation did not require a specialized, fixed mechanical setup for every unique problem; instead, a single machine could simulate any mathematical logic if guided by an adaptable set of instructions.

This concept was made a physical reality in 1945 when the Hungarian-American mathematician John von Neumann formalized the von Neumann architecture in his First Draft of a Report on the EDVAC. Von Neumann broke the foundational constraint of early computing by dictating that data and the instructions operating on that data (software) should be stored together in the exact same physical memory substrate. This conceptual leap eliminated the need to physically rewire circuits or change mechanical gears to switch tasks.

By treating code as fluid data that a CPU could dynamically read, write, and modify in memory, Turing and von Neumann shattered the boundary between hardware and software, instantly replacing rigid physical mechanisms with a boundless, programmable reality.

Manufacturing: Steam-Engine Factories vs. Electric Drive

During the late 19th century, the Second Industrial Revolution introduced the electric motor, a technology that promised to liberate manufacturing from the constraints of steam power. Since the early 1800s, factories had been structurally designed around a singular, massive steam engine. This central power source distributed kinetic energy across the factory floor through an incredibly complex, high-maintenance, and dangerous labyrinth of overhead shafts, iron gears, leather belts, and pulleys. When early electric motors became commercially viable in the 1880s and 1890s, factory owners did what seemed entirely obvious: they executed a 1:1 replacement.

They unbolted the giant steam engine, hooked up a single, massive direct-current (DC) electric motor in its place, and left the entire centralized architecture of overhead belts and pulleys completely intact.

For nearly thirty years, this "faster horse" approach yielded deeply disappointing results. Productivity gains were marginal because the underlying operational bottlenecks remained completely unchanged; factories were still plagued by massive friction losses along the drive shafts, constant mechanical downtime, and rigid, inflexible floor layouts.

The true paradigm shift did not occur until the 1910s and 1920s, when engineers and architects stopped viewing electricity as a mere substitute for steam and began treating it as a decentralized energy network. Pioneered by innovators who understood the flexibility of alternating current (AC) systems, the manufacturing industry realized that electricity allowed for fractional power, the ability to scale down power generation efficiently to individual units. Instead of a singular, monolithic engine driving the entire facility, engineers placed a small, dedicated electric motor onto every single machine on the floor.

This architectural breakthrough completely eliminated the centralized drive shaft. Free from the requirement of aligning machinery along rigid, parallel linear lines close to a steam engine, factory architects completely reimagined industrial workflows. Production floors were redesigned based on the natural, logical flow of raw materials to finished products, giving birth to the modern assembly line. By abandoning the centralized constraint, fractional electrification transformed the factory from a rigid, mechanical cage into a fluid, highly optimized ecosystem, fundamentally unlocking the twentieth century's manufacturing boom.

Communications: The Skeuomorphic Newspaper vs. The Hyperlink

In the mid-to-late 1990s, as the World Wide Web emerged as a disruptive cultural and commercial force, traditional media institutions faced an existential crossroads. The initial instinct of legacy newspaper and magazine publishers was to treat the internet as a faster, cheaper printing press, a digital distribution mechanism for an analog format. Media executives executed a direct, skeuomorphic translation of print journalism onto the web.

They took daily print editions, scanned them, and uploaded them as static, non-interactive PDFs, or forced content into rigid, multi-column web pages that strictly mimicked the physical layout of a broadsheet. In this "faster horse" era, the underlying concept of media remained completely unchanged: a centralized editorial board curated a fixed, monolithic package of text and images that was pushed out linearly to a passive audience once every twenty-four hours. Publishers simply used the new digital infrastructure to replicate the structural constraints of physical paper, completely failing to grasp that the web was a fundamentally different medium.

The true paradigm shift arrived in the 2000s and 2010s, when a new wave of native web platforms abandoned the legacy concept of the "page" entirely, realizing that digital media could be completely decoupled from physical forms. Innovators shifted from static, pre-rendered files to dynamic database architectures where content was broken down into modular, liquid data points. Rather than forcing users to consume a fixed layout, platforms leveraged user-generated content, hyperlinking, and bidirectional feedback loops.

This architectural fluidity culminated in the invention of the algorithmic feed, a continuous, non-linear stream of information that constantly mutates and reconstructs itself in real time based on user telemetry and behavioral attention loops. By breaking the constraints of spatial layout and static daily publishing schedules, the internet transformed media from a collection of rigid, physical products into a fluid, self-evolving ecosystem of attention, fundamentally reshaping global communication and information consumption.

02 Where Are We Now?

It depends on where you look and how you measure it. Objectively, so far only some areas of software development have been significantly affected by recent advances in LLM code generation.

The Temptation of Pure Velocity

In the nascent era of AI-driven software abundance, the most immediate and intoxicating temptation for engineering teams has been the pursuit of sheer, unadulterated velocity. Developers are using agentic systems to completely eradicate legacy backlogs that previously choked product roadmaps for quarters or even years.

Instead of spending weeks meticulously triaging technical debt, refactoring old boilerplate, or manually writing thousands of missing unit tests, teams are unleashing continuous loops to clear out JIRA queues overnight. For example, an engineer can now task an autonomous agent with refactoring a sprawling, poorly documented legacy API gateway, updating its dependencies, and writing complete test coverage while they sleep.

This massive injection of execution speed turns software maintenance into a hyper-efficient background process, making the old manual slog feel completely obsolete. Of course, there are the usual caveats related to code security and, say, debuggability.

Automation on Steroids and SaaS Replication

Beyond merely fixing the old, the second major temptation is the aggressive replication and rebuilding of entire software ecosystems on a whim. Because the friction of generating functional code has plummeted toward zero, developers are using multi-agent loops to build "automation on steroids," frequently spinning up complete, customized clones of established software-as-a-service (SaaS) platforms over a weekend.

Rather than paying exorbitant enterprise licensing fees for rigid, third-party software, engineers are tempted to build hyper-tailored, internal versions of platforms like CRM systems, project management tools, or analytics dashboards. For instance, a developer can instruct a swarm of coordinated agents to replicate the core data pipelines and user authentication workflows of a platform like Salesforce or Notion, adapting the entire UI to their exact specifications with minimal manual intervention.

The code itself ceases to be a sacred asset, becoming instead a cheap disposable commodity that can be generated, deployed, and thrown away at will. Meanwhile, customer acquisition is probably as difficult as ever.

High-Fidelity Polyglot Reimplementation

Perhaps the most technically sophisticated temptation lies in the automated, low-level reimplementation of foundational libraries and packages to optimize performance without breaking existing systems. With AI capable of understanding deep abstract logic across multiple programming paradigms, developers are increasingly rewriting critical infrastructure from scratch, specifically translating legacy code into memory-safe, high-performance languages like Rust. There are entire companies like CodeMetal for whom this is the basis of their business.

A prime example of this is taking a highly complex cryptography library originally written in Go and autonomously translating it into Rust to extract maximum execution speed and better memory management, all while rigorously preserving absolute semantic correctness. Similarly, teams are tempted to take heavy server-side image processing or data serialization pipelines and instantly rewrite them as highly optimized local Rust binaries to achieve local pixel-precision processing.

Existing test suites can ensure that the newly synthesized code mimics the precise cryptographic or algebraic properties of the original library, achieving massive hardware optimization with zero cognitive friction for the developer.

03 Code Generation vs. Agentic Loops

Automation is a powerful force. We are living through a moment of greatly increasing efficiency. Loops in agentic coding systems continuously monitor the software's execution environment and output to self-correct and optimize logic in real time. By shifting the human's role from writing or reading code to defining mathematical boundaries, these loops allow systems to be created without direct human supervision while generally maintaining operational integrity. Whether Boris Cherny's current conception of loop engineering is a true paradigm shift or just the ultimate faster horse is an interesting question.

If you look closely at what Cherny describes, autonomous background agents continuously refactoring architecture, identifying duplicated abstractions, and submitting pull requests, the uncomfortable reality is that current loops are largely still the ultimate faster horse. They are hyper-efficient (especially if you ignore the token budget), autonomous engines running inside a legacy cage.

04 What is Next?

The software engineering landscape is rapidly moving past the era of mere code generation.

Middle-Term: Closing the Box

In the middle-term, we are moving aggressively into an architectural paradigm where the supervisory role of the human is radically reduced. The custom of keeping a Human-in-the-Loop (HITL) to rubber-stamp every pull request is dissolving at least in some places, shifting the human from an active supervisor to a higher-level architect. This gives rise to what we might call black-box software development: the architect defines what the system must do and what invariants it must preserve, but never actually reads the generated code. The implementation becomes an opaque artifact, produced and maintained entirely by autonomous agents, with the human's only window into it being the behavioral contracts and specifications they authored. Just as a building architect does not inspect every brick or weld, the software architect inspects policies, not lines. Whether this is liberating or alarming depends on how much you trust the verification layer standing between you and the machine's output.

Long-Term Horizon: The Probabilistic Organism

In an upcoming post, we will explore the profound structural advantages of autonomous software over the rigid, "fixed" software models we have all grown accustomed to. Chief among these benefits is how autonomous systems elegantly resolve the eternal tension of precise specifications. In classical software engineering, the greatest failure point has always been the translation of ambiguous human intent into rigid, deterministic code. If a specification misses an edge case, the software breaks. Autonomous software completely subverts this dynamic. By decoupling the goal from the implementation, the developer no longer needs to specify how the software should behave in every conceivable scenario; they only need to mathematically define what the system must preserve.

We believe that in some domains we are close to abandoning the decades-old model of fixed software designed to be read, maintained, and parsed by a human developer. When software becomes cheap, fluid, and autonomous, forcing a hyper-dimensional AI system to output linear text files into a Git repository is revealed as a legacy bottleneck.

How to Keep Things Safe?

If and when software becomes truly autonomous and self-evolving, it leaves the predictable realm of fixed, deterministic instructions behind and enters a world of continuous, probabilistic adaptation. These systems cease to behave like static machines; instead, they operate like biological organisms. They actively perceive environmental changes, evaluate their own performance through real-time telemetry, and autonomously modify their internal execution graphs to meet new operational demands.

Specifically, the idea of applying static verification becomes near-impossible in this context as well because of the mercurial nature of software artifacts.

To pull off this level of fluid execution safely without risking catastrophic failure, the architecture requires an unyielding foundation: meta-level formal verification layers. These runtime guardrails may act as a dynamic, automated, and persistent safety net. The software is free to mutate, optimize, and rewrite its internal logic probabilistically in response to changing external stimuli, but it is physically prevented from breaching the invariant boundaries set by the human architect.

It is, quite fundamentally, the realization of a system that builds itself, boundless in its execution, yet absolute in its integrity.

05 Conclusions

So the real question is not how fast our horse can run, but whether we should still be building stables at all.

The history of science teaches us that true mastery lies not in making the horse run faster, but in recognizing when a paradigm shift is called for.

References

• Salehie, M., & Tahvildari, L. (2009). Self-Adaptive Software: Landscape and Research Challenges. ACM Transactions on Autonomous and Adaptive Systems, 4(2), 1-42. link
• Ishaque, M., Siddiqui, Z., Alzahrani, M. H., & Almqdashi, H. M. (2026). The Self-Healing Software Organism: An Evolutionary Runtime Defense Framework for Autonomous Regeneration. 2026 International Conference on AI Innovations and Industry (ICAIII), 1-6. link
• Self-Healing Autonomous Software Code Development. (2022). International Journal of Emerging Trends in Computer Science and Information Technology, 3. link
• Sardar, T. H., Pandey, B., & Aldasheva, L. (2026). LLM-Powered Autonomous Security Agents for Next-Generation Cyber Defence. 2026 IEEE 5th International Conference on AI in Cybersecurity (ICAIC), 1-5. link
• Boris Cherny on Why Engineering Is Already Solved, 2026. YouTube