Disposable Software -- Abstractions Are the Complexity?

In the previous post we discussed whether rewriting software could become cheaper than maintaining it. This time I want to look at abstractions.

Abstractions

Software engineering is full of abstractions. Consider the basic Internet. It starts with a browser, which uses HTTP (of some version) to fetch the content of the page, next it deals with HTML, JavaScript, graphics, process isolation and many things in the browser engine to render a page for you, on your phone. HTTP usually runs over TCP, or, with HTTP/3, QUIC over UDP. Underneath, we use IPv4 or IPv6, stacked into the Internet protocol suite. It all runs on top of operating systems, which are based on hardware abstractions and software abstractions.

My point here is to highlight that we accept complexity of some components or layers of our solutions. That is normal to assume that a basic Internet page just works, and most of the time we do not go beyond that abstraction to the deep technical details.

There are, of course, rare cases when one needs to dig as deep as possible to optimize their software and gain drastic improvements in performance, stability and other aspects. Joel Spolsky called it The Law of Leaky Abstractions – every non-trivial abstraction leaks to some degree

I hit that when listing files on macOS – it ended up in native APIs and system calls.

We accept complexity and abstractions when doing software.

AI Agents

With the rise of AI Agents I see another abstraction which comes into play.

Now you may not even know how your application works, or what code is written there. You may trust your AI Agents did the right work and covered it with enough tests. It can be specs, it may be no specs, it may just work. I wrote before that code review is the real bottleneck once AI Agents generate code faster than we can read it.

Of course, for more complex applications, people tend to understand, review, test, and manage AI-assisted changes. I want to share my own experience doing devrig.dev:

I have deep experience dealing with Java/Kotlin applications, IntelliJ API, and related backend/desktop software application stacks. And if I were to review the code – it would be a deep review with enough fixes and improvements. On the other hand, I can understand HTML, CSS, JavaScript, TypeScript and other web technologies, but I have much less experience to have a deep opinion on the code, given the code renders decently. I wrote more about devrig here.

The New Abstraction

With AI Agents, we can create Disposable Software to solve problems faster. There is no requirement to fully understand that software, how it’s tested, and so on. We may trust and validate an AI Agent’s work. In my case, integration tests kept the MCP contract while AI Agents and I rewrote the transport.

Given that, I believe we are going to shift the abstraction level of complexity even further.

Just assume, you are running a service which does the work, it uses the database, and other tools internally to work. Or even SAP or Spring Framework. And you have no idea what’s inside. These are the implementation details, and such details are now hidden behind a new abstraction, very much like the classic information hiding principle

With AI Agents we hide software implementation details behind the new abstraction level.

Complex Systems

You may want to stop me and say that there are still huge and complex systems, which had been created for decades, such systems have way too many edge cases, and tricks, and details, and these are the details the business wants to keep untouched.

I am not against that. And I personally believe I can help you use AI Agents to work with such big monoliths. We did it for a release roadmap of a large product, and with MCP Steroid AI Agents work inside IntelliJ on big codebases.

Our industry invented microservices architecture (Martin Fowler’s article) to solve the complexity problems of such complex systems. And it’s still an open discussion if microservices are the best solution, see Monolith First and Microservice Trade-Offs. With AI Agents, I see it’s changing.

Agentic Microservices

Let’s borrow the idea of mathematical induction as an analogy. Given one can create a service that solves the basic business needs with AI, and such service implementation is fully hidden behind the new abstraction. How would you deal with more complex systems?

My answer is to use Agentic Microservices. The whole idea is to turn a complex system into a swarm of smaller services, each created with AI Agents, and each is talking to each other to create a more complex solution. Even the binding of such services can be implemented as yet another service. It is similar to what we do with AI Agents themselves, when AI Agents manage AI Agents via run-agent.sh.

The interfaces and interactions still need to be tested, for example with contract tests. I think that approach will bring similar discussions and technical challenges as we had with monolithic systems and microservices. It will open new opportunities to create solutions with AI Agents on the other hand.

Summary

The first – we are doing disposable software. The code and the implementation details are the new abstraction which hides everything.

The second – we connect such services together as Agentic Microservices. It will allow to create even more complex systems.

This will move the most of our software development to use the natural language and prompts, to describe the system and its services, just as I wrote in Coding in English with AI. Just like one may not know today how exactly the CPU’s L3 cache works when a web page is rendered.

Support my work · Work with me