Lately, while I’m coding, I have a strange feeling.
Not that I can’t code or don’t want to. But—
It feels like I’m becoming less and less necessary.
Previously, for a feature from requirement to launch, the path was basically this:
I understand the requirement → design the solution → write code → debug → fix bugs → launch
What does it look like now?
I describe the requirement → AI writes the code → AI fixes the bugs → I glance at it → launch
That big chunk of “writing code” has suddenly become very thin—almost nonexistent.
At first, this was pretty cool.
But as time went on, I started to feel uneasy.
In the past, programmers got satisfaction not only from completing tasks but also enjoyed many joys during the process of writing code.
The act of writing code seems less important
I used to think that the core ability of a programmer was writing code.
Whether you write fast, elegantly, or abstractly well—these differences defined your level.
But now, this standard is gradually losing its power.
Much of the code can actually be written by AI faster than humans, and it’s not necessarily worse.
Especially for things like:
- CRUD
- API integration
- Routine logic handling
AI basically dominates in efficiency here.
Sometimes I write something myself and subconsciously send it to AI:
“Can you optimize this?”
And not only does it optimize it, but it also adds edge cases I didn’t think of.
That moment is a bit subtle—
You start to lose track of who wrote that code.
What’s even stranger is: you start not wanting to write it yourself
This is the most dangerous part.
Writing code used to give you a sense of control:
Every line was typed by you, you knew why it was written that way, and where problems might occur.
But once you get used to handing problems over to AI, you’ll find:
Writing it yourself actually becomes slower.
You might even feel:
“Why should I write it myself?”
This isn’t laziness—it’s natural efficiency optimization.
Just like you wouldn’t manually calculate large integers, you won’t want to hand-code things that can be automated.
Programmers are becoming a different kind of role
Slowly, you’ll notice that what you do every day has changed.
No longer about:
- How much code you write
- Which design patterns you use
- Whether the code is beautiful
But instead:
- What exactly does this requirement want?
- How should I describe it so AI doesn’t misunderstand?
- Is the result correct?
The majority of your time is no longer spent writing code—but rather—
figuring out the problem clearly.
This was always important, but now it becomes the most critical part.
Code seems to have become an “intermediate product”
One day, I suddenly realized something:
We always thought “code is the product,”
but now it feels more like—
Code is just a temporary result in the process.
What truly matters is:
- Input: what you said (requirement / prompt)
- Output: whether the result is right
As for the middle code, it could even be:
- Not written by you
- Not written by a human
- Or never truly read by anyone
This sounds disruptive, but it’s getting more real.
So what were we competing over before?
If code can be generated automatically, then all the things we used to compete over—
- Syntax fluency
- Hand-coding skills
- Code style
—suddenly seem less important.
They’re not useless, but—
they’re no longer decisive advantages.
You realize a somewhat cruel truth:
The skills you worked hard to build may just be “the optimal solution of the previous generation.”
For example, someone who doesn’t know how to code using AI managed to jump onto GitHub trending in a short time. This made me feel powerless about my decades of accumulated experience.
This might be the tragedy of older-generation programmers—and yet, we must admit that the younger generation can indeed surpass us.
The most awkward group of people
It’s not those who can’t write code. It’s—
Those who still see “writing code” as their core value.
If you’re still:
- Worrying about whether syntax is elegant
- Spending time hand-coding repetitive logic
- Measuring output by “how much code you write”
Then you’re essentially:
👉 Optimizing a process that’s being automated.
This doesn’t mean effort is worthless—it means the direction may have shifted.
So what do we still have left?
I’ve been thinking about this for a while.
Eventually, I found that what remains is actually few, but crucial:
Can you clearly articulate the problem?
Can you judge whether the result is correct?
Do you know what truly needs to be solved?
These abilities, AI still can’t replace.
Or at least, it’s hard to fully replace them.
Will “people who hand-code” really be killed off?
Maybe not.
But “people who only know how to hand-code” will definitely struggle more.
What gets killed isn’t the person—it’s the role:
- Only responsible for implementation
- Doesn’t define the problem
- Doesn’t judge the result
Such roles will become increasingly marginalized in the age of AI.
One final change
In the past, we said:
👉 A programmer turns requirements into code
Now, it’s more like:
👉 A programmer turns “ideas into results”
Whether code is used in the middle,
or what kind of code is used,
doesn’t matter as much anymore.
Sometimes I wonder:
If one day AI can write all the code,
Are we still programmers?
Or—
Shouldn’t we have never been defined solely as “code writers”?
Final thoughts
AI becoming the future is basically a done deal.
From PHP, .NET, Java, Python, mobile development, to today’s AI—in just a few decades, the profession of programmers has kept changing. Tools keep evolving,
but the core ability of programmers has never changed—
solving problems
We thought we were learning languages and frameworks,
but in reality, we’ve always been practicing:
how to turn a vague problem into a definite result.
