Self-extensible software is here and its amazing

Source Material

This is an X article I published about self-extensible software.

We probably have a little bit of time before the all consuming machine gods take over our machines and everything is simulated. So until then, traditional software is probably going to stick around... right? Right!

Back in the dark ages, when code was expensive, one developer would build software for many people. These days, since code is cheap, everybody can build their own bespoke software? Software is truly dead right?

Well.. I guess the reports of software's demise are greatly exaggerated.

The truth is, people use prepackaged software because they don't want to build the dang thing from scratch, even if they could. I could build a house myself, if I wanted a shittier house at 3x the price that took 10x as long to deliver. I just want to buy a good house and customize it. The same goes for software.

Prepackaged software isn't going away. So does this mean the AI revolution is over? Pack it up? No, it means there's some truth in the middle. Self-extensible software is a happy medium.

We've had extensible software for as long as software has been around, but its always required a developer to build extensions for. Tons of software operate on this model, from dev tools to blogging platforms (Wordpress) to payment platforms (Shopify). People love extensibility. You can take a piece of software that handles 80-90% of what you need, then just adapt it for your own use case or how you want to use it. The only problem is that it used to cost a lot, you had to pay a costly developer for their time.

With coding agents though, you can now ship a developer INSIDE your software!

The developer is INSIDE the computer?!

While working on my self-extensible agent harness Neon Pilot (heavily inspired by the Pi coding agent), I've come to believe that self extensibility is the next core component of software. If you've used Pi before, there is a point where you tell your agent to create an extension for itself, and it just... does it, and it works. And then you get that "holy shit" feeling and you can't go back to regular software.

I'm going to talk about what I've built and what I've learned from building Neon Pilot and from @badlogicgames and Pi.

Making software self-extensible

The recipe for self-extensible software is relatively simple. You need:

A coding agent (inside your software)
A runtime
An extension API inside your existing software
Documentation for the agent

Neon Pilot is a coding harness, so a coding agent is already core functionality. We bundle Pi as the core agent harness and heavily extend it. For more traditional software, you can bundle one of the many available agent harness SDKs into your software.

The Pi coding harness and NP run on Node. You need an interpreted language in order for users to build extensions because you can't bundle a full developer tool chain or expect users to have all the necessary tools on their system. So you use an interpreted language and everybody's happy (...mostly...).

The real meat and potatoes of self-extensible software though is the extension API and documentation. The extension API defines the capabilities that the agent can use to build extensions, and the documentation provides the how. You need both, and this was one of the key insights from the Pi coding agent.

In Pi, right inside the agent's system prompt is a link to Pi's documentation. The agent is able to read documentation very easily and use that to build extensions. That's how it "just works". The agent is never guessing how to build extensions, its given everything it needs.

So this translates to self-extensible software as a capability layer exposed as the extension API, and a repository of documentation that the agent can read and draw from to build an extension.

The extension API is the next piece. To make extensions truly useful, you need to expose primitives of your application. The more raw the primitive, the wider the range of things the agent can build for the user. For example, if you expose a database primitive, then the agent can build dang near anything, whereas if you just expose a rigid API then the scope of extensions an agent can build is limited to the API.

It'll be up to the people building products to decide what level of customization they want their users to have. Users also have a say though, and if they want certain functionality, they'll also have the ability to hack it in or work around your system's limitations. So it's a push/pull.

Extensibility is good, customization is great

I fully expect more and more companies will augment their own applications with extensible surface areas. Big companies will struggle with this more. Its harder to turn a huge ship and it will be more difficult to build augment-able surfaces into their legacy systems.

Smaller companies that build extensible systems from scratch will be able to natively support this from inception, and this will be a huge boon to their business. What kind of business doesn't want to give customers the exact solution they want? It's always been a struggle to do this in the past. Its now possible, and those companies that embrace this will be able to provide a better product for users.

We're so early

If you've gotten this far, the message I want you to take away from this is that it is still very early days. We're in the TUI/console days of building self-extensible software and the solutions are only available to people developing software. We're still learning how to work with these new systems, and I fully expect more and more of these lessons to start to disseminate into the wider world.

I don't believe that some pie in the sky all consuming machine god that will take over our lives. That's a myth used to pump up company valuations since we simultaneously exist with two truths. We are in a bubble, and we are also experiencing a stepwise improvement in technology. The two truths can coexist. The realistic view is that the future lies somewhere in the middle, a world where software isn't dead, but we also unlock new capabilities that make the products better.

For me, that's self-extensible software.