On the topic of ending uncreating and AI agents

I am the architect who now wrestles with the bricklayer.

I never thought the aim of coding would be about typing the actual code and figuring out undocumented arguments of a polymorphic Python function. Yet, up until the last 2 years, myself and my students would spend time uncreating: a term I could only describe by all the things that are just useless but unavoidable. My favourite example used to be loading the data for a machine learning task. How many datasets had to be loaded, sanitised and processed in order for one to answer a research question? All that effort now brought about the end of the uncreating age as we venture into the maximum-likelihood of brick laying.

The battle

For most of my career, programming was a battle between what I wanted to create and mechanical friction like syntax errors, boilerplate, configuration, you name it. We used to go to a hackathon and spend a good first few hours trying to get a web application with user login. I recall just skipping password resets because it was just too much effort to code. There were some shortcuts like a premade repository that had user management, a dashboard and more built for you, but then you would spend hours trying to wrangle out the magic it came with.

Coding is a creative endeavour. We are trying to create something that hopefully did not exist before. It should venture into the unknown and have challenges, algorithms and hidden surprises. It should be a new bridge that makes something possible. However, I probably spent a good deal of my early research career fiddling with trying to get things moving. To give a few examples: matplotlib is a very good example of uncreating. Instead of visualising what you have, you spend more time trying to make it visualise, digging through generic arguments and documentation. Another would be pytorch; scattered across many contributor packages, functions, modules, the idea of doing something outside the box for research was more about beating PyTorch with a hose rather than trying to answer a question.

So how did we get to this point? We accelerated technology so fast that abstractions had to be built. The more we abstracted, the more impure and convoluted the tools, libraries and the programming languages we use became. At least, this is a working theory I have.

The new struggle: prouumpt

It works, it doesn’t work, that’s not the debate here. I think anything that gets me further away from uncreating, I’ll take it. In this case, AI agents, LLM autocompletes, etc., have all managed to push me away from some really nasty uncreating cases. Especially for common tasks like loading a dataset, I’m grateful. In the past, due to time constraints, before a deadline I used to show to my supervisor the results of the experiments in CSV or JSON format. Yet, I now ask my students to ask an LLM agent to produce a beautiful interactive page for every experiment, every result and every hypothesis. The caveat, they have to ensure the results are correctly portrayed. But this, as I see it, gets us closer to creating.

Of course, there are times where it fails miserably. And ironing these out, or arguing this model is better will never end. I thought the first type checking libraries for Python were good until they weren’t because they couldn’t deal with something like NumPy properly. The agentic era is no different; it comes with its own limitations and it is up to you to choose what you prefer to deal with: continue the old battle or take the prompt…

Be no architect without laying bricks

A question I get asked by my students: Is software engineering dead? I think the complete opposite. If anything, it is becoming what it should have been: an architect who imagines, creates and oversees the technological advancements. However, the harsh truth is without laying bricks yourself, you can be no architect. Especially, when the brick laying is now done by an AI agent that spits out thousands of lines of code. The temptation to just accept, auto-commit and move on is probably where the difference between the architects of tomorrow and the prompting gurus lies.

There is some debate whether the AI agents are going to be so good that they can architect themselves and also go on to lay the bricks taking the human element completely out of the process. This would probably happen for the cases where the maximum-likelihood is very high. There are only so many ways you can build a login page for your application and thank goodness we built thousands of them. But, let’s consider an example like trying to build a new distributed orchestrator like Kubernetes. It’ll probably be more of a collaboration between human architects and AI trial and error.

The end of uncreating?

I’m not sure if there is an actual end of uncreating. Perhaps that is the point. We only get further away from uncreating. With new tools and advancements along the way, usually most aspects push us away from it. But with every step we take, there is some new dimension in which uncreating happens.