For most of the history of software engineering, writing code was expensive.
Not financially expensive, but cognitively and temporally expensive.
A feature might take days to implement. Refactoring a bad design might take weeks. Deleting code was painful because of the sunk cost. If you spent three days building something, you would fight hard to justify keeping it.
Code carried weight.
You thought carefully before starting because once you committed to a direction, changing course was costly.
That assumption is starting to break.
AI has made code cheap.
Not perfect. Not magical. But undeniably cheap.
The Old Constraint: Time to Code
Traditionally, the bottleneck in building software was time to implementation.
You could imagine a feature in minutes, but turning that idea into working code required:
- writing boilerplate
- remembering APIs
- fighting type errors
- searching documentation
- debugging edge cases
- stitching pieces together
Even experienced engineers spent most of their time just getting code into existence.
Because of this, the industry evolved around minimizing coding effort:
- frameworks
- scaffolding tools
- code generators
- libraries for everything
- design patterns that optimized developer effort
The goal was always the same:
Reduce the cost of writing code.
AI changes this equation dramatically.
The New Reality: Code is Abundant
With modern AI tools, code generation is no longer the expensive part.
You can produce working scaffolds, implementations, tests, and even refactors in minutes.
What used to take hours now takes prompts.
This means something subtle but important:
The cost of throwing code away has collapsed.
Deleting 500 lines of code used to hurt.
Now it doesn’t.
A Small Personal Example
Recently I had been brainstorming and implementing a feature for a product I’m building.
I spent a few days thinking through the design and writing the implementation.
Eventually I stepped back and realized something uncomfortable:
I didn’t like the direction.
In the past, this realization would have created friction.
Three days of work is not something you casually discard. You try to salvage it. You convince yourself the design is “good enough.” You iterate around it rather than abandoning it.
But this time I did something different.
I deleted the code.
All of it.
And started again.
Not because the previous version was broken.
But because it wasn’t the right idea.
The Psychological Shift
AI lowers the cost of implementation so much that it changes the psychology of development.
When code is cheap, you stop optimizing for preserving it.
Instead you optimize for finding the best idea.
The workflow becomes closer to sketching than construction.
You try an idea.
You see how it feels.
If it’s wrong, you throw it away and try another.
The New Bottleneck
If code is cheap, then something else becomes expensive.
The new bottleneck is:
- problem understanding
- product thinking
- architecture decisions
- taste
- judgment
In other words, thinking.
AI can generate implementations, but it cannot decide whether the idea behind them is good.
It can write code.
It cannot tell you if the product direction makes sense.
That responsibility still belongs to the human.
Disposable Code
This suggests a shift in how we should think about code itself.
For years developers were taught:
Code is an asset.
But increasingly, code behaves more like a sketch.
Something you produce quickly in order to explore an idea.
Sometimes the sketch becomes the final piece.
But often it is just a step toward the real solution.
When code is cheap, the willingness to discard it becomes a competitive advantage.
The Danger of Cheap Code
There is also a risk here.
If code is cheap to produce, we may drown in it.
Repositories filled with AI-generated implementations.
Layers of abstractions nobody deeply understands.
Large codebases that grow faster than teams can reason about them.
Cheap production does not automatically mean good design.
In fact, it can make bad design easier.
Which again points back to the real bottleneck:
clarity of thought.
What Developers Should Optimize For
If implementation is becoming easier, developers should invest more in the things that remain difficult:
- understanding problems deeply
- designing systems carefully
- maintaining conceptual integrity
- simplifying architectures
- developing taste
The future advantage is not writing code faster.
It is knowing which code is worth writing at all.
The New Development Loop
The development loop is quietly changing.
It looks less like this:
Think → Implement → Commit
And more like this:
Think → Generate → Evaluate → Delete → Try Again
Iteration cycles shrink.
Exploration increases.
Bad ideas die faster.
A Simple Rule
The rule I’m slowly adopting is simple:
If the direction feels wrong, delete it.
Not refactor.
Not patch.
Delete.
Because with AI, rewriting is often cheaper than repairing.
And sometimes the fastest way to progress is to start over with a clearer idea.
Code is Cheap. Thinking Isn’t
AI didn’t eliminate the difficulty of building software.
It just moved it.
The bottleneck is no longer typing code.
The bottleneck is deciding what should exist in the first place.
Code is cheap.
Thinking isn’t.