Does Anyone Still Remember How to Code?
There’s a trending post on X today:
does anyone remember how to code
The post comes from Nikita Bier. It has racked up tens of thousands of likes and sparked a lot of discussion among developers.
What I find interesting about this line is that, as a joke, it points to a real tension in how AI Coding is developing:
We are gaining unprecedented capacity to produce software, while possibly losing direct control over the process that produces it.
1. AI Coding Is Reshaping What Programmers Are Good At
In the past, a programmer’s skill was largely measured by how well they could turn requirements into code.
Now, as Coding Agents get more capable, more and more work can be handed to AI: designing data structures, implementing interfaces, writing tests, tracking down bugs, even cross-module refactoring.
That means the skills programmers practice day to day are shifting.
You used to write a lot of Java by hand every day. Now you probably spend more time describing requirements, reviewing proposals, reading diffs, and running tests.
There is something worth watching out for here: a skill doesn’t have to disappear completely to degrade. It degrades simply because you use it less.
For example, a developer who has relied on AI to generate SQL for a long time may still understand how SQL works, yet gradually lose the fluency to write complex queries quickly by hand.
But I don’t think this kind of skill decay, on its own, proves that AI Coding is a bad thing. We stopped expecting most developers to write assembly long ago, and software engineering didn’t go backwards because of it.
The real question is: which abilities can we hand off to tools, and which must humans keep?
2. What Worries Me More Is the Decline of Understanding
I think there are three distinct layers of ability here.
| Ability | How it changes in the AI era |
|---|---|
| Writing code | Being heavily automated |
| Understanding code | Still important, but may be eroded by reliance on AI |
| System-level judgment | Becoming even more important |
Here’s an example.
Suppose you ask a Coding Agent to implement a high-concurrency message-consuming module in a Spring Boot project.
It can quickly generate the Pulsar Consumer, thread pool, exception handling, and retry logic.
But you still need to judge:
- Is the concurrency reasonable under the Shared subscription mode?
- How should message acknowledgment be coordinated with database transactions?
- Could retries cause duplicate processing?
- What happens when the downstream database slows down?
- Can the system recover when a consumer backlog builds up?
AI can answer these questions, and may even give you a design that looks complete.
But if developers can no longer independently judge whether those answers are reliable, system quality increasingly depends on the model’s accuracy.
That is what I consider the most dangerous part.
3. But I Don’t Agree with Sanctifying Hand-Written Code
Part of why this post resonated is that programmers are uneasy about how their professional identity is changing.
Being able to write complex code fluently used to be a professional skill worth being proud of.
Now, someone without years of programming experience may use AI to quickly build features that once required a senior engineer.
It’s easy for this shift to create a feeling that years of accumulated skill are being devalued.
But looking at the history of software engineering, rising levels of abstraction have always been the norm.
From assembly to high-level languages, from manual memory management to garbage collection, from operating servers directly to cloud platforms, every step forward reduced the work developers had to do themselves.
So I don’t believe programmers must insist on writing code by hand to stay competitive.
I’d even argue that if AI can reliably do a certain kind of coding work, insisting on doing it manually may no longer make economic sense.
The problem is that today’s AI is still far from reliable enough to be trusted unconditionally.
4. What Deserves the Most Attention Is How Future Programmers Grow
This is what worries me most about the whole topic.
Senior engineers can judge whether a technical design is sound largely because of extensive past experience implementing, debugging, and stepping on landmines themselves.
If future junior programmers complete their work mainly through Agents from day one, how will they build up that experience?
This could become a long-term problem:
When a generation of programmers no longer needs to personally go through building complex systems, how do we train the next generation of people who can understand complex systems?
Of course, AI could also be an excellent teaching tool, helping newcomers grasp knowledge that once took years to encounter. It all depends on how they work.
If newcomers just keep accepting whatever AI generates, they may learn very little.
If they keep verifying results, studying why things fail, and understanding design trade-offs, AI could actually accelerate how fast they gain experience.
5. I Think Two Kinds of Gaps Will Emerge
The first is the gap between people.
Developers who are good at using Agents and also have solid engineering judgment may achieve productivity far beyond anything before.
The second deserves more caution: the gap between the complexity of software a developer can produce and the complexity they can actually understand.
AI can let one person maintain a system that once took ten people to build. But if that person only understands a small part of it, risk accumulates as the system keeps growing more complex.
This may become a major challenge for AI-native software engineering.
My Conclusion
I’m not worried that future programmers will forget how to write certain APIs or language syntax, or even be unable to quickly build a CRUD module without AI.
What I care more about is this: when an Agent submits thousands of lines of code, does the developer still know why it was written that way, where it might go wrong, and how to track down a problem when one occurs?
The core competitive edge of great programmers in the future may increasingly lie in being able to understand, verify, and control the complex systems that AI produces.
That said, I also hold a judgment I’m not yet sure about: as Coding Agents keep advancing, the code review and human judgment we emphasize today may also be largely automated. When that happens, how much implementation detail programmers actually need to understand remains an open question.
So I think Nikita Bier’s line could be rewritten as:
Does anyone still understand the code?
That may be a question more worth discussing than “does anyone remember how to code.”