In Defence of Liquid Code

With the release of Actium (apps.apple.com/app/actium/id6796930580) on the Apple App Store and CEP (CEP Field Notes · Anthologic), I now see myself as a little bit of an expert in coding. Jokes. What I mean is I want to promote the idea that there is a new type of code I call “Liquid Code”.
Of course I did no coding to create Actium. I haven’t coded anything significant for over 25 years. Importantly, I didn’t stop coding because I thought it was somehow beneath me. I stopped because I didn’t like the cottage industry of functional activity that seemed to feed off the value of code.
I started writing Manage Without Them (Manage Without Them: The Book – ManageWithoutThem) because of this feeling - because I thought the management function was part of the problem of functional organisation. But that’s another story.
I put down the coding tools and began a slow and lumbering career shift into the strange mix of management consultant, business architect, systems thinker, and executive dogsbody that is my career now: Anthologic — Collected Works in Organisational Design & Transformation.
Like many others I have been using AI to write tools and fun applications, partly because creating in this way is enjoyable. Actium itself replaces DEVONthink (for me, at least; power DEVONthink users should probably keep using DEVONthink, which is a great application).
With the progress of AI coding agents everybody has an opinion on AI coding. Coding has emerged as the first “killer app” of the AI-driven future.
It’s the future, it’s “slop”, it’s not real coding, and it’s not maintainable. If you find yourself unable to find some utility in modern AI I’d suggest you are not being very imaginative.
But the ability to produce and maintain high-quality code versus bad code is a serious distinction.
If you think about the maintainability of “Liquid Code” (for now just think of it as the code that AI produces, but there is more to it than that) you have to understand the maintainability of code in general.
Most code is not maintainable for most of the people on Earth. This is just a fact. Programming is a skill that not everybody has so code is not maintainable by most people.
It takes a level of expertise that most people don’t have just to make the distinction between good and bad code, maintainable and not maintainable code.
But you can’t say that “Liquid Code” is not maintainable. “Liquid Code” is provably maintainable because AI coding agents are maintaining it right now. It might be that it’s not maintainable by humans but it’s certainly maintainable by other AI coding agents.
Of course the maintainability of the code is different to whether the code is any good. Just because an AI agent can continue to update code created by an AI agent doesn’t mean it will ever become good quality code.
There are objectively good ways to code. True expert coders have specific and valuable skills and knowledge about what is good code. But when an experienced coder is asked to fix an issue with a program and sees that the whole thing needs to be rewritten they will rewrite it (just try and stop them).
There is no guarantee that the next experienced developer won’t rewrite everything again - and they might be right to do so given the change required. So there is simultaneously an objective way to evaluate good and bad code but also at the same time two experienced developers at different times might just rewrite the code.
Code gets rewritten all the time and nobody knows. People using the code evaluate it on features and utility and habit. What really matters is if the code does what it’s supposed to.
Programmers call it “refactoring” and it’s fundamental to modern software development. Rewriting the code to make it do the same thing but better. Better could be faster, more maintainable, easier to reuse. But it still does what it did before.
And software developers have therefore developed ways of automatically confirming the code still does what it did before. “Automated tests” built into the integration and build pipeline run to ensure the code hasn’t broken.
Because software is complex you can break things you haven’t even changed because there might be an unintended consequence through a chain of dependencies or interactions.
So the automated tests aren’t just run when you change the code they relate to. You can run all the tests and confirm nothing is broken across everything. Maybe the tests are incomplete but you can fix that because they are code too.
This isn’t that different to product managers or managers in general. You need to be explicit, but not as explicit as you need to be to code. And to be a hands-off manager and give a suitable amount of autonomy you sometimes have to be less explicit anyway.
Alternating flow
The key to getting good results - and by this I also mean building things that are interesting and not just the same application you could produce yourself in the same amount of time if you were a skilled developer - is alternating between the big picture and the details.
When giving AI coding agents a task you can either specify in detail what you want them to do or you can give them a high-level direction and let them fill in the details. I find that alternating between the two is the best approach. Early in the AI / LLM boom the advice was to be specific in your prompts (remember the “prompt engineering” wave?). LLMs performed better when you told them something very specific.
It’s no longer the case that a specific direction is the right approach. Or rather, it’s no longer a question of optimising what we as users evaluate as the LLM’s performance. If you give an LLM a specific prompt it does a better job of executing the user’s intent in that prompt, for sure. But that is not always the optimal result.
So often in my early AI coding experience I requested a feature be developed in a very specific way and then a few days later realised there was a better way to develop it. Conversely, when giving a high-level prompt the feature was often built in a way that I didn’t expect that turned out to be right. The AI has access to the code and the history of intent in a way I don’t always have top of mind when I think of a feature, so it’s not about which is performing better but how to get the right result - in circumstances where I might not always be best at determining the right result at the point I am asking for it.
In other cases a tight, very specific request is required to ensure the agent doesn’t forget some fundamental requirement while trying to resolve an issue. Reading carefully what the agent is planning to do often reveals that it is missing something fundamental that has never been discussed. Calling this out is important and usually the agent “recognises” that it’s fundamental and captures that “new” information for later.
Fluid Dynamics
Liquid can be controlled in broad strokes or in tiny capillaries. It might seem like this is just a question of doing the same thing at different scales. A hydroelectric dam channels water and so does a plant.
Liquid code flows into cracks. Where an organisation has a set of core applications and an imperfect investment process (that’s a lot of organisations) liquid code fills in the gaps - valuable code that there wasn’t a business case for before but is valuable.
Liquid code is temporal. Fill in the gaps, but just as easily wash it away when it’s no longer required. It’s “production ready” for now - the only question is “production” as the IT service boundary defines it or “production” as in used for real work?
Liquid code is a cool glass of water and it’s the cordial. It’s personal taste, it’s small scale if you want it, and it’s either foundational or an additional flavour.
Liquid code behaves differently to normal code because nobody observes it completely. This is fluid dynamics versus billiard balls. It’s quantum versus Newtonian. That sort of thing.
It’s faster to fix liquid code because nobody is attached to it. If you’ve always made a distinction between “responsible” and “accountable”, or made a case for independent or black box testing, then you can handle a little liquid code.
Liquid code is also more maintainable than other code. Most of the population of Earth cannot maintain most code. Code maintainability has been scarce since inception.