Code was never the hard part

If you think writing code was ever expensive - you got it wrong

The role of what you do really changes over the lifecycle of a project. The beginning is always easy. Greenfield and no boundaries or problems. (Kinda like people felt when they first started vibe coding.)

After a while things get slow. You act and find some cool abstractions, shared code and layers. And things become cool and dandy again. (Just like when you just keep on telling the AI what you want more and more precisely.)

And then at some point a requirement changes that you haven't foreseen and then your domain model breaks. Or your data model is not flexible enough. And then shit hits the fan. Hundreds of places that need changes. Depending on how skillful the developer was, the project lacks tests, proper structure, or all of the above.

Kinda like when you vibe code through hell and then you decide to just build it all over again. And that's the point. Nowadays you can do that.

So case closed. AI is cheap and easy.

Lets have a serious look.

No matter what you do - in the end, generating code costs money. The expensive part is building an accurate mental model of the problem — and finding the solution that actually scales in your domain.

That always has been the expensive part. That always will be the expensive part. Generating code is truly much cheaper than before and this will and should change the way we work. It doesn't take away the core of what a good developer does. Managing complexity.

The curve.

I really think all a developer does is trying to slow the rate at which complexity compounds. At all cost prevent it from becoming nonlinear.

And as you see with all the viral vibe coding examples. People end up hitting the steep part of the curve earlier. Things that took developers in the past years to realize is now becoming evident within weeks or months.

That's the actual insight. AI doesn't remove the complexity curve. It compresses the timeline to get there.

Teams can now move from prototype, to traction, to architectural pain, to scaling problems in a fraction of the time. The complexity didn't disappear. The timeline collapsed.

And that is already pretty telling. AI bends and skews that curve it makes you quicker in learning. But it doesn't give you a free pass to skip the hard parts.

And despite it causing devs to get more lazy about their code, you can use it to write the most amazing code much much faster than you could ever before - if you burn through some tokens of course ;)

So whats the interesting question you should ask yourself?

If we still have to obey code complexity - And the curve has been bent. How much effort should I put into writing good code? Will that save me tons of tokens later, because I spent some time to think about a scalable architecture? Or will AI become so cheap and good that you truly just don't give a damn?

In the end I would recommend you try to spend more time in understanding the user / the problem that you are trying to solve before you start writing or prompting code. That makes you a better developer in any time frame.

The bottleneck was never syntax. It was understanding.

AI changed the economics of implementation. Not the economics of complexity.