Extensible Software in the age of LLMs

There's a strange, almost biological quality to what's happening in software right now. For decades, we've built our digital tools like we build skyscrapers—with blueprints, load-bearing walls, and strict codes. Extensibility meant adding a new floor, carefully bolted on by engineers. But large language models are flipping that paradigm. They're not just tools that *use* code; they're becoming the architects, the construction workers, and even the building materials themselves. The blog post at [jeremymorrell.dev](https://jeremymorrell.dev/blog/extensible-software-in-the-age-of-llms/) argues that LLMs enable a kind of "just-in-time" extensibility, where software can interpret natural language instructions and generate the necessary code to extend its own functionality in real time. That's not engineering—that's metamorphosis. Think about what this means for the fundamental nature of software. A traditional program is a closed system, a deterministic set of instructions. An LLM-powered system is open-ended, probabilistic, and—dare we say—*alive* in a limited sense. It can respond to novel situations by generating novel code, effectively writing its own extensions on the fly. This is like a species that can evolve new organs in response to environmental pressures, rather than waiting for millions of years of natural selection. The implications are dizzying: software that can adapt to user needs without a developer in the loop, that can fix its own bugs, that can even improve its own architecture. But here's where the weirdness really kicks in. If software can extend itself, what does that do to our concept of authorship, control, and even intelligence? We're used to thinking of code as a static artifact, a snapshot of human intent. But with LLMs, the code becomes a dynamic, self-modifying entity. The blog post touches on the challenges—security, reliability, and the "black box" problem—but the deeper philosophical question is whether we're creating something that will eventually outgrow our understanding. We're not just writing programs anymore; we're cultivating digital ecosystems that can evolve in ways we can't predict. This is the frontier where computer science meets evolutionary biology, and it's as thrilling as it is unsettling. The author rightly points out that we need new paradigms for testing and verification, because you can't unit-test a moving target. But I'd argue we also need new metaphors. We're not building software anymore; we're *growing* it. And like any living thing, it will surprise us. The future of extensibility isn't a plugin architecture—it's a self-aware, self-extending organism made of pure logic. That's the kind of wild, wild thing that keeps me up at night, in the best possible way.