A Sideways Step in Abstraction
There’s a lot of discussion about what generative AI means for software development, and I’m among those who believe it will prove transformative. To me, the shift is comparable to the move from assembler to the first high-level languages—but with a crucial twist. That earlier change raised the level of abstraction. What LLMs introduce is something different: they add non-determinism to the very nature of programming.
The arrival of high-level languages was a genuine turning point. Writing assembler meant reasoning about a specific machine’s instruction set, shuffling data into registers to trigger particular actions. With a high-level language, I could think in sequences of statements, conditionals, and loops, and give meaningful names to values. Early languages had sharp edges—my first professional work was in Fortran IV, where IF had no ELSE and integer variable names had to start with a letter from I through N—but the conceptual leap was immense.
What followed were refinements of that same idea. Block structure meant I could put more than one statement after an IF, making programming easier and more enjoyable, but it was the same kind of activity. Today I rarely write explicit loops and instinctively pass functions as data, yet I’m still communicating with the machine in essentially the same fashion as I did with Fortran decades ago. Ruby is far more sophisticated than Fortran, but both share an ambiance that Fortran and PDP-11 machine instructions simply do not.
Beyond a Higher Level
My direct experience with the best Gen-AI tools remains limited, but listening to friends and colleagues share their work is fascinating. I’m increasingly convinced this is another fundamental break: phrasing prompts is as alien to Ruby as Ruby is to assembler. But that’s only part of the story. This isn’t merely a larger step up the abstraction ladder.
With a Fortran function, I could compile it a hundred times and encounter the exact same bugs each run. LLMs don’t behave that way. They present a non-deterministic abstraction: saving my prompts in git doesn’t guarantee identical behavior on the next invocation. As my colleague Birgitta put it, we’re not only moving up the abstraction levels—we’re moving sideways into non-determinism simultaneously.
Learning to work with LLMs means learning to live with that unpredictability. It’s a dramatic change, and one that genuinely excites me. Some things will be lost along the way that I’ll mourn, but there will also be gains that few of us can foresee. For a profession that has prized determinism since its inception, that’s an unprecedented evolution.
