A few months ago, I carelessly left my old document folder on the table. You know the kind – that collection from a previous life: certificates, childhood drawings and school reports. School reports you never actually want to see again.
My 12-year-old daughter flipped through it and remarked dryly:
“Dad, you were a disaster.”
She was right.
The main reason for this catastrophe was in my childhood bedroom at the time: a Commodore C16, Christmas 1984, I was 14. For my parents it was a device, for me it was a portal. While other children played outside, I spent hours typing code from magazines. Line by line. Error by error. Hope by hope.
That was how you got games back then. These magazines were essentially our app store. We called it “programming”. In reality, it was more of an early form of concentrated capacity for suffering.
Level 1: Machines speak
I learned, I practiced, and at some point I became good. I programmed low-level assembler code. In other words, I wrote code that even I could no longer understand a week later: we called it “Write-only code”. A term that has proved remarkably durable. The world was small. The developers were few. And computers understood only their own language. In the 1980s, BASIC was the promise – and assembler was the reality. On systems such as the C64 (my second computer) or the ZX Spectrum, you could get something running quickly, but as soon as it had to be fast, attractive or even controllable at all, there was no way around the machine itself. Abstraction was a luxury you could only afford later.
Anyone who wanted to play with these machines had to adapt. The computer made no attempt whatsoever to meet us halfway. We had to learn its language, accept its logic, endure its strictness. (Anyone who has ever tried to debug assembler knows what I mean here by strictness)
Level 2: We learn their language
Then came higher-level languages. C, later C++ and the unspeakable Basic. These languages had already existed for some time, but now we had computers that allowed us to use them. For me it was an IBM 286, my first Intel architecture. Each of these languages was a step away from the machine – and a step toward the human. Memory no longer had to be managed entirely manually, structures emerged, abstractions became possible. And with each of these abstractions, something decisive happened: more and more people were able to program. That is the actual (historical) core of this development. Higher-level languages do not just make software development faster, but more accessible. They strip it of exclusivity. In a certain sense, they democratize it.
With every new language came the same criticism: too far away from the hardware, too little control, too much convenience. This criticism runs like a thread through the history of software development. And it was always wrong. Because this loss of control was the prerequisite for progress.
Level 3: Interfaces for people
At some point, it was no longer enough for only developers to be able to operate software. The world wanted interfaces. GUIs (Graphical User Interfaces) emerged. Windows. Buttons. Mouse pointers. In the early 1990s I worked at Siemens in the PSE. We were proud not to have graphical interfaces. Our software was used by machines, not by people. At the time, that seemed to us like a sign of technical seriousness. I only understood later that the essential development lies precisely at the interface between human and machine. Software does not become significant because it is technically excellent. It becomes significant when people can work with it, enjoy using it.
Level 4: The web abstracts everything
Then came the web. The browser became the universal platform. APIs replaced direct system access. Infrastructure moved into the cloud.
And once again, the same thing happened: more abstraction, more speed, even more people who could create software. No, the quality did not improve as a result. Many problems that would once have been solved in code were now beaten down with computing power. In many places, elegance was replaced by scaling. That is not always beautiful, but often remarkably effective. In retrospect, it is amusing when today’s software developers talk about a loss of control at the sight of agentic coding. This control was not lost yesterday. It has been in orderly retreat for decades. But something else essential is happening here. Software is no longer developed and built for every use case. It already exists, or exists differently, and can now be created very quickly. Let us imagine an example from another industry: there are thousands of companies worldwide that sell water. Not a single one produces water. The water is already there. These companies filter it, package it, transport it and put it into a context in which we can use it.
In a certain sense, this is exactly what has happened to software over the years. We are producing it less and less often in the original sense. We combine, abstract, orchestrate. The real value no longer arises only from writing code, but from making it usable.
Level 5: Computers learn our language
And now something fundamentally new is happening. For the first time in history, it is no longer people who are learning the language of computers. Computers are in the process of learning our language. Natural language is becoming the interface. What used to look like this:
// dummy-code for (int i = 0; i < n; i++) { value = extract_feature(data, i); score = evaluate(value); aggregate(score); }
now looks like this:
“Write me a function that analyzes this data and shows me the anomalies.”
This is not a small improvement. It is a paradigm shift. For decades, progress consisted of placing the next generation of programming languages one level higher. Now language itself is becoming a development environment. And with that, the barrier to contributing to software continues to fall.
Level 6: Agentic Coding
Multi-agent systems are capable of producing excellent code in a short time. They understand models, discuss architectural problems and find solutions. Not always perfectly, but which programmers could claim that of themselves. The much-praised elegance, the painting of code, as I myself liked to call it, this act of creation is not being lost. It is simply becoming more broadly accessible. Even if that contradicts some romantic notions: truly robust assembler knowledge is rare today. Without the emergence of higher-level languages, many people would never have become programmers. This entire industry would not exist in its current form at all.
That is precisely why agentic coding is not a devaluation of programming, but its next opening.
Goals, rules, context, context, context
In our company, project onboarding is taken seriously. Not out of sentimentality, but out of necessity. Everyone who works on a project has to understand why we are doing something, what goals are behind it, and how we intend to approach them. Software development has always been an approximation of goals, never their immediate fulfillment. That is precisely what is now becoming more important than ever. Complexity does not disappear. It shifts. The advantages are many. We can assess with significantly greater certainty how long development will take. Budget risk decreases, predictability increases. And we can focus more strongly on the questions that really count: system understanding, causality, architecture, and responsibility.
In software engineering, we spend 15 or 20 percent of our time writing code. The rest is understanding, structuring, coordinating, evaluating, discarding, and starting again. The crucial question is therefore no longer: Can you program? The crucial question is: Do you understand what you are building here?
We don't develop software anymore - We prompt software into life
I am curious to see what my daughter will one day put into her own folder. Her generation will interact socially with artificially created beings as a matter of course. The software for these systems will have been designed and developed by the computers themselves. Our task will then be to guide this new form of development in such a way that it serves people and remains committed to the good of humanity. My daughter has different interests than I do; she lives for language and she lives for music. But with very high probability, we can say that she will program. In the past, we had to learn the language of computers; today, computers are learning our language. And that is – despite all justified skepticism – actually quite beautiful.
About the author:
Jürgen Schmidt is an entrepreneur in software development and AI research. In addition to this work, Schmidt is a frequent keynote speaker at specialist conferences and teaches as a guest lecturer at universities.
The article was published on derstandard.at in April 2026