I remember being awed by programming in college. In an advanced programming course, we read Structure and Interpretation of Computer Programs. Each class felt like magic, like we were breaking a mold of some kind, that programming was more than sequential instructions and library calls. One example that always stands out when I think of that time was learning about ‘memoization’ though a function that would change itself to remember previous results.
I found that so elegant, code that changes itself.
Programming felt like magic back then. Most people felt this magic, whether they copied and pasted spells from Stack Overflow or just spent a long time condensing their code to be ‘just right’.
I felt proud writing smart code. Smart, concise, expressive code. After Lisp, I settled for Scala as a way to have my cake and eat it too within the Java ecosystem. I remember feeling whole with the simplicity of functional programming. I loved looking at small snippets of code. I even wrote and published a paper on comparing snippets of code and their impact on code duplication.
The beauty of code lay in the small, witty things we said to each other.
Programming changed a lot in the last 10 years.
You see, more than 25% of code is written by AI now 1 2. I’m not talking about auto-complete. Rather, AI producing the code. This number will increase in 2026.
The attention we’re giving to code is reducing. There is an indirection between developers and code. The ownership of the code hasn’t changed, but the process of arriving at a solution has. I don’t think this is a bad thing. It just is.
However, this indirection is not another level of abstraction like the introduction of high-level programming languages (think C to Python). An abstraction keeps a straight line between your intention (written in your code) and machine code in a deterministic way. It builds on top of layers of construction and lets you do magic with simple, obvious things. You don’t have to understand all the layers of code that sit between your software and machine assembly code. You only have to know your own code.
AI is something different. It feels more like gambling. Like opening loot boxes. You trade your money for tokens and you roll. ‘I wonder what I will get now’. ‘Please make it right’. You blow on your dice, put some extra sprinkles in your prompt and may the RNG (random number generator) gods be in your favor. There is no line between your prompts and your code. Your prompts were a dialogue, they’re not documentation. AI makes you think that you don’t need to know your own code. That code doesn’t matter. But your code is still your code. Maybe there will be a time when we take spec files and compile them to code without leaking. Until then, coding with AI is something else.
And coding with AI feels freaking great. You feel incredibly productive. It fills all the blanks and assumes the right things we didn’t think about. You stop thinking about code for the most part. And this is not a gotcha for maintainability. Maintainability is an issue, sure, but that will be solved. Because code doesn’t matter.
Code is meant to be discarded now. Coding agents can compete with their implementations. And you can then ask them to make tests for those implementations. And then you can ask them to review the code.
There is a slightly depressing view where you will have to pay a tax to build software: you need to pay for your tokens. Maybe we will be like those gambling addicted folks, pulling the levers of the slot machines, attracted by the flashing lights, wishing for just the right software, just this time. All while we slowly forget the house always wins and is making bank on all the kilometers of lines of code wasted away.
With AI I get to feel like a programmer again. I use Deep Research to find out everything I need to know, I then review those requirements with Claude to make sure they’re tight, I feed that into an agent in Cursor to create an implementation plan and then I ask Lovable to code that plan. The amount of ideas you can explore is addictive. I can build things faster than I can think, with only some general direction. I’m not special enough for AI to feel confused about my wishes, I fall under the standard deviation so I’m likely to want whatever it suggests. And I do, I typically do.
So now tokens are productivity and performance. Spending tokens is a sign of respect. More than performance, it’s street cred.
All to say that code is not the skill anymore. It’s how well you can get AI to make code. This all reduces the importance of code.
Things are different. But different is not necessarily bad. Change is hard. Software and programmers were always going to be commoditized. It was too much of a good thing.
Code doesn’t matter anymore. Code is pointless. Programming languages are pointless. He who tells you otherwise wants to sell you something.
What I worry about the most is the dependence that a whole industry is making on a small few number of companies that write our software for us. That can charge more for each dice roll. That tell us that code doesn’t matter while building a monopoly around it.
Long gone are the days of small beautiful code.
For 90% of software, code never mattered. Those were lies we told ourselves. Code was a means to an end.
In its most atomic element, software elicits feelings. Of joy. Of productivity. Of reward. Of connection. Software makes you feel less bored, more fulfilled, less contained. Proof: look at the market cap of software companies and think about what they sell.
Software shouldn’t have been treated as engineering. Because the end result requires so much humanity.
Over the years, all we’ve been doing is bubbling up toward the user. Our ancestors wrestled with machine code deep in the stack so that C developers could walk. C developers managed memory so that Python developers could express themselves in one true way. We’re moving closer and closer to the end user. AI is the final level of the elevator. The distance to the outcome of what software is meant to do has been reduced to small paragraphs we call prompts. Users never cared that you had smart beautiful code. They cared about how your software made them feel. That was the case before and will continue to be.
People who built software thinking about the end outcome of user feeling and experience will continue having the same job but easier. Most others will have a hard time.
Some code will matter. I hope AI is not used to maintain Linux. At least not soon. But it probably will.
Building software is about making something people want. Not need. Want. That is the thing. Whatever you do to get that thing, is the thing you need to do.
As software changed, I changed too. I feel the nostalgia of caring about small snippets of code. Longing for small, beautiful things.
Today, I feel the rush of putting some more coins in the slot machine and making things no one will see.