Today AI does a great job at generating code for programming languages. However programming languages are higher level abstractions that make it easy for us human to read, write, debug and maintain code. These higher level abstractions ultimately translate to machine level instructions depending on the hardware systems.
With programming languages in place we have developed systems, processes specifications to standardize how we as humans will operate these systems. This has lead to us building out version control systems, CI / CD pipelines, micro service architectures (to name a few) and many other systems.
Now with advancements in AI we are trying to use AI to make these processes efficient. We are trying to shoe horn AI into our processes. However we are quickly hitting the limits. Example in case: Github servers being overwhelmed with exponential increase in pull requests because of the rapid pace at which AI agents are generating code.
It feels to me that "we" are limiting AI to what we humans can fathom and keep up with. It feels like programming languages are a limitation to the software AI could potentially generate. Human processes like version control, PR approvals limit the deliverables of an AI agent.
A clean-slate thought experiment
What if AI could start on a clean slate for software engineering ? What if there were no programming languages and AI could come up with "its native" way of software engineering ?
Today's constraints on software engineering are:
- Humans and the processes we have built around software engineering
- Hardware systems on which we run the software
For this thought experiment, I am unable to think of alternatives to the existing hardware systems and will continue to accept that as a constraint for software engineering.
With the above premise set, the work of the software engineering could be reduced to say, defining the intents of a system and AI would be able to execute it as it deems fit. The goal of the AI would be to fulfill the intents.
Let's take an example of coming up with an eCommerce system. The main intents of an eCommerce system, just to list a few of them, would be as follows
- Allow the ability to stock up items
- Allow the user to search items
- Allow the user to purchase items that are in stock
- Accept payment from user
- Ship the item to the user
The above are very simple high level intents for illustrative purposes. The point being that we should be able to define a system and its intents and let AI generate a software artifact that helps achieve the goals of this intent.
In this fictional world, we would not have a say on the "how" of the implementation. We would only state "what" and AI would do its thing.
In my limited imagination AI probably would directly generate machine level code to run on hardware. It probably may not need pull requests or IDE's but it might need some sort of version control to keep tabs on what versions of artifacts are deployed on these hardware systems.
We probably would give it non-functional requirements like
- User must be able to checkout within x ms
- Hardware budget must not exceed x $
- Turn around time to create new features must be within a certain period of time
It would be up to the AI to optimize for these non-functional requirements.
Overall it feels like we would relinquish complete control to these systems while it fulfills our requirements.
Are we ready ?
Now the question is, "Are we ready to relinquish complete control to AI ?" Artificial Intelligence was already present long before this recent boom of LLMs and AI Agents. What definitely has changed recently is how we are able to interact with AI in natural language and how LLMs are able to produce output that we as humans can fathom. We as engineers have the innate urge to understand systems we work with. We like to have certain degree of visibility and control on the "how" of software systems.
It feels like "humans" are a necessary evil to AI, like "friction" is a necessary evil to physical motion.
Top comments (1)
The clean-slate question is interesting. Even if agents use a different internal representation, operators still need inspectable invariants and a way to reproduce failures; the human interface might change without eliminating accountability.