AI can now generate a non-trivial application in a single shot.
That changes everything.
And it raises a question many developers are quietly asking:
If AI can write the code… what’s left for me?
You Were Never Hired to Type
Let’s start here.
You were not hired for your ability to type.
You were hired because you can:
- understand complex problems
- model systems
- make tradeoffs
- bring clarity to ambiguity
Code was always just the medium.
Now AI is accelerating that medium.
And that’s where things get interesting.
The Real Shift
When AI enters the picture, something subtle happens.
The bottleneck moves.
It’s no longer:
- “Can we implement this?”
It becomes:
- “Do we understand what we’re building?”
- “Are we structuring this well?”
- “Where do decisions live?”
AI removes friction from execution.
Which means it amplifies everything upstream:
- your thinking
- your design
- your clarity (or lack of it)
Why AI Feels Uncomfortable
Many developers are experiencing a strange tension.
On one hand:
- AI feels incredibly powerful
- it can generate entire systems quickly
On the other:
- the code doesn’t feel quite right
- the structure is off
- it’s harder to evolve than expected
That discomfort isn’t about AI.
It’s about design.
AI Is an Eager Junior Developer
When I work with AI on code, I see a familiar pattern.
It behaves like a very capable junior developer:
- eager to build features
- quick to create new structures
- less concerned with long-term design
Left alone, it will:
- duplicate logic
- invent unnecessary abstractions
- optimize locally instead of systemically
That’s not a flaw.
It’s a mirror.
The Mirror Effect
AI reflects the quality of your thinking.
If your instructions are:
- vague
- fragmented
- implementation-focused
You get:
- brittle systems
- misplaced responsibilities
- hard-to-test code
But if your thinking is:
- structured
- intentional
- grounded in design
AI becomes a force multiplier.
Where Design Actually Lives
Here’s the deeper insight.
Design is not:
- class diagrams
- clean syntax
- patterns applied from memory
Design is:
the placement of decisions and responsibility
Every system answers questions like:
- Who owns this data?
- Who makes this decision?
- Where does behavior belong?
When those answers are unclear…
The system struggles.
AI doesn’t fix that.
It exposes it.
A Simple Example
I once worked on a system where IDs were managed globally.
It seemed reasonable at the time.
But that decision forced us into using Singletons across the codebase.
The result:
- code that wasn’t reentrant
- difficult testing
- tightly coupled components
The fix wasn’t adding another pattern.
It was moving responsibility.
We pushed the data into the objects that needed it.
The Singleton disappeared.
Not because we removed it…
But because we no longer needed it.
The Same Problem at Scale
This happens everywhere:
- overuse of inheritance
- misplaced abstractions
- objects that ask instead of act
Developers often use inheritance to “add behavior.”
It works once.
Then it breaks:
- substitution fails
- variation becomes rigid
- classes explode
The root issue is the same:
The decision was placed in the wrong location.
AI Raises the Stakes
Before AI, poor design slowed you down.
Now?
AI accelerates you into it.
You can build faster than ever…
But if your design is weak, you:
- arrive at complexity faster
- accumulate debt faster
- lose control faster
That’s why AI feels both exciting and dangerous.
The New Role of the Developer
So where does that leave us?
Right where we’ve always been—but with greater leverage.
The developer’s role is not disappearing.
It’s becoming more visible.
We are:
- system designers
- decision-makers
- model builders
We work with:
- structure
- behavior
- tradeoffs
And now:
we collaborate with AI to bring those decisions to life
This Is Bigger Than Software
These skills aren’t limited to programming.
They are:
- systems thinking
- logical reasoning
- pattern recognition
- iterative development
These are the skills required to work effectively with AI in any domain.
That means developers are not becoming obsolete.
They are becoming:
increasingly relevant
A Hard Truth
The software industry has struggled for decades.
According to Standish, most projects still fail or underperform.
We’ve normalized:
- missed expectations
- slow delivery
- growing complexity
AI changes the equation.
When organizations can get working systems in hours instead of months…
Expectations will shift.
Dramatically.
The Opportunity
This is the moment.
Not to write more code.
But to:
- think more clearly
- design more intentionally
- guide systems more effectively
AI doesn’t remove the need for developers.
It removes the illusion of what developers do.
Final Thought
If you think your job is to write code…
AI will replace you.
If you understand that your role is to:
- shape systems
- place decisions
- guide complexity
Then AI becomes your partner.
And your leverage.
