It’s fashionable to say—or at least it was until recently—that AI is just the latest in the long history of programming abstractions. Developers have always managed to move up the ladder: punched cards → assembly → C → scripting languages → frameworks. Each transition was met with some resistance, often called as inefficient or inferior, and yet each ultimately got adopted because it enabled developers to build increasingly complex software. AI is simply the next rung on that ladder.
But at the risk of repeating what everyone said about new technology in the past, this time it really is different.
Historically, each new level of abstraction took time to permeate the developer psyche. Programmers gradually adapted, learned to think at a higher level, and eventually became comfortable with the new tools. AI, however, isn’t merely another layer, it’s abstraction of abstraction itself.
When ChatGPT first arrived, it was remarkably good at generating code, but most of us used it for snippets, boilerplate, and configuration files. Cursor brought AI directly into the editor, giving it visibility into entire codebases and allowing developers to delegate more substantial tasks. It was impressive, but its limitations were visible as tasks grew more complex and codebases larger.
Then came Claude Code and other agentic coding tools. Suddenly, AI could navigate repositories, modify multiple files, run tests, and iterate on its own mistakes. Quite impressive but still complex tasks warranted supervision and the code some healthy suspicion.
Fast-forward to today, and AI can execute astonishingly complex tasks with remarkably little supervision. As much as I’d like to deny it—and believe me, I’ve tried many times over the past three years—the bottleneck increasingly seems to be imagination rather than complexity of the task itself. That doesn’t mean we’re anywhere close to casually vibe-coding a polished alternative to Photoshop, despite what some enthusiasts would have you believe.
But an enormous amount of my everyday programming can now be delegated with relatively little hand-holding.
These days, I deliberately throw absurdly complex tasks at AI, and I half-expect, perhaps even hope, that it will fail. Part of me wants to be reassured that my technical abilities still matter. Yet, it always succeeds, often delivering something that far exceeds my expectations.
The biggest shock came when I shared a screenshot of a rendering issue in Camoufox to Claude Code. Despite seeing nothing but garbled characters, AI correctly identified the underlying problem. It was genuinely dumbfounding. How could it diagnose an issue from just a screenshot, without any logs, or additional context?
Inevitably, I have become more and more on Claude code for my everyday work. I do intervene. I suggest refinements, request refactoring, and occasionally correct its approach. But increasingly, those interventions feel like matters of taste rather than technical necessity. I’m no longer doing the difficult work. I’m reviewing someone else’s.
On one hand, I find all of this incredibly exciting. The possibilities are extraordinary. Software and complex ideas that languished in my to-do list can now be brought to life with little more than a prompt. On the other hand, I’m struggling to keep up with the pace of change and the reason is abstraction fatigue. It is the mental exhaustion of constantly having to adjust what you’ve to do as a programmer. Just when you grow comfortable with a new way of working, AI advances enough to make parts of that workflow obsolete and you’ve to delegate more stuff to keep up.
Previous generations of programmers had years, sometimes decades, to adjust to a new level of abstraction. But here, it feels like I have climbed several decades’ worth in a span of three years.
Think about how much has changed in such a short time. AI began as an extraordinarily capable programming assistant, helping with snippets, debugging, and the occasional tedious task. Early coding assistants were largely an extension of that, except they had the context of an entire codebase. But now, it has completely taken over the responsibility of intellectually demanding parts of programming.
And it’s not merely that AI can do these things. It’s that it can often do them better than you’d expect, sometimes better than you could have yourself.
I’m no longer sure I’m the programmer. Increasingly, I feel like a manager of a superhuman one.
It does make my job easier, and I am adjusting (I suppose), but there’s a deeply unsettling question behind all this, how many rungs are left on this ladder? And what happens to me when I get to the top?