When I started coding around the turn of the millennium, assembler was already history for me. Turbo Pascal, Perl, Java, PHP, JavaScript — that was the toolbox. I learned, in theory, how memory works and how the binary system underneath it all behaves. I never set a register by hand. I never punched a single card. There was no need to: higher-level languages were simply a faster way to get things done.
Trust Had to Be Earned Once Before
That leap from close-to-the-machine languages to higher-level ones wasn’t universally welcomed. Every generation of developers who made that jump had to place trust in a compiler they didn’t fully control — trust that it would do the right thing with the instructions they wrote. That trust wasn’t given freely. It was earned, compiler release by compiler release, project by project, until scepticism quietly gave way to habit.
Higher-level languages won because they let us work far more efficiently. The cost was a layer of control we handed over, willingly, in exchange for speed.
A Familiar Leap, With a Strange Twist
We’re at a similar threshold again, except this time it feels different. We’re handing trust to AI that writes code for us, and we still look over its shoulder with a wary eye. How long will that scepticism hold? How long can we afford to keep it up, and how long will anyone keep paying us to?
At some point, trusting the AI will simply be the efficient thing to do. But there’s a catch the compiler shift never had: a compiler is deterministic. Give it the same input twice, and you get the same output. An AI model doesn’t work that way. Trusting a system that might behave differently tomorrow, on the same prompt, feels genuinely strange — not because it’s new, but because it breaks an assumption we never had to question before.
Where That Leaves Me
So here I am, standing roughly where the assembler developers once stood, watching a new generation of tools arrive that promise to make the old scepticism look quaint. I don’t know yet whether I’ll cross that threshold the way they eventually did, or whether non-determinism is the one thing that keeps this leap fundamentally different.
Have you noticed your own scepticism towards AI-written code softening, or is it holding firm? I’d be curious where you’ve landed.