Skills AI can't replace: what developers should learn now
AI writes more code than ever. These are the developer skills that still matter: reading code, debugging, breaking problems down, and design judgment.
If an AI assistant can write the function for you, what is left for you to learn?
Short answer: the judgment around the code. AI is fast at producing code. It is much less reliable at knowing whether that code is right, whether it fits the rest of the app, and what to build in the first place. Those are the skills worth your time now.
This post covers five of them, each with a small example of what it looks like in practice and how to get better at it. If you are still deciding whether to learn to code at all, Is learning to code still worth it in the age of AI? is the place to start.
1. Reading code you didn't write
Most of your working day, AI or not, is spent reading code: a teammate's pull request, a library's source, or a function an assistant just suggested. The difference now is volume. You can get 40 lines in a few seconds, and you are responsible for every one.
Here is a function an assistant might hand you. It looks reasonable:
async function loadRatings(ids) {
const ratings = []
ids.forEach(async (id) => {
const res = await fetch(`/api/movies/${id}`)
const movie = await res.json()
ratings.push(movie.rating)
})
return ratings
}It returns an empty array every time. forEach doesn't wait for async callbacks, so return ratings runs before any fetch finishes. No error, no warning, just missing data.
The fix is to collect the promises and wait for all of them:
async function loadRatings(ids) {
const movies = await Promise.all(
ids.map(async (id) => {
const res = await fetch(`/api/movies/${id}`)
return res.json()
})
)
return movies.map((movie) => movie.rating)
}You can only spot the first version's bug if you know how forEach, promises and await actually behave. That is the point: you can't review code you couldn't have written. JavaScript async/await explained covers this exact trap, and Promise All (opens in a new tab) is the lesson.
How to practice: before you accept a suggestion, say out loud what each line does. If you can't, that is the part to learn.
2. Debugging
AI can suggest fixes, but it often guesses. Debugging is a method, not a guess: reproduce the problem, read the actual error, form one idea about the cause, and test it.
A small example. You need a list of scores in order:
const scores = [10, 9, 1]
scores.sort()
console.log(scores) // [1, 10, 9]That isn't a bug in JavaScript. By default, sort compares values as strings, and "10" comes before "9" alphabetically. Passing a compare function fixes it:
scores.sort((a, b) => a - b) // [1, 9, 10]If you paste the broken output into a chat, you may well get the right fix. But if you understand why it happened, you will recognize the same pattern the next time, in a place where nobody points it out. Sort (opens in a new tab) covers it.
How to practice: when something breaks, write down your guess about the cause before you ask anyone, human or AI. Then check whether you were right.
3. Breaking a problem down
"Build a watchlist app" is too big for anyone to get right in one go, including an AI. "Fetch the movies, show them in a list, let the user filter by genre, show a message while loading and another one if the request fails" is something you can build, test and check one step at a time.
That skill, turning a vague goal into small, checkable pieces, is what makes AI tools useful instead of chaotic. A clear, small request gets a clear, small answer you can actually review. It is also the skill that interviews and real tickets test most.
How to practice: before you write code or a prompt, list the steps. Each step should be small enough that you would know if it was done wrong. The project in What Youll Build (opens in a new tab) is a good exercise: build it one numbered step at a time.
4. Design judgment
Code that works today can still be hard to change tomorrow. Here is a common example: the same rule written in two places.
// checkout.js
const shipping = total > 50 ? 0 : 5
// cart-summary.js
const freeShipping = total > 50The day free shipping moves to 75, someone updates one file and forgets the other. Now the cart says shipping is free and the checkout charges for it. Putting the rule in one function avoids that:
function qualifiesForFreeShipping(total) {
return total > 50
}AI assistants tend to solve the problem in front of them, which is how a rule ends up copied into a second file. Noticing that, and knowing when it matters, is a judgment call. So is naming things clearly, keeping functions small, and deciding where data should live. If you want to go deeper, Knowledge In One Place (opens in a new tab) covers this example.
How to practice: after something works, ask "what would I need to change if this requirement changed?" If the answer is "three files", that is worth fixing.
5. Explaining your decisions
As more code is generated, the people who can explain why the code looks the way it does become more valuable. That shows up in pull request descriptions, in code reviews, in bug reports a teammate can act on, and in interviews where you are asked to walk through a project.
A good explanation answers three questions: what changed, why, and what you considered and didn't do. If you can't answer the second one, you probably shouldn't merge the code yet.
How to practice: for your next project, write a short README that explains one decision you made and one alternative you rejected.
What to spend less time on
Some things matter less than they used to:
- Memorizing exact syntax and API names. You still need to recognize them, but looking them up, or letting your editor fill them in, is fine.
- Typing boilerplate. Setup code and repetitive patterns are where AI tools save the most time.
- Collecting tutorials. Watching someone else build is a slow way to build the five skills above. Writing and fixing code yourself is faster.
The skills at a glance
| Skill | What AI does well | What you still own |
|---|---|---|
| Reading code | Produces a lot of it, quickly | Deciding whether it is correct |
| Debugging | Suggests likely fixes | Finding the real cause |
| Breaking problems down | Handles small, clear steps | Turning a vague goal into those steps |
| Design judgment | Solves the problem in front of it | Keeping the whole app easy to change |
| Explaining decisions | Summarizes what code does | Knowing why it should look that way |
Common mistakes
- Skipping the fundamentals because AI covers them. The fundamentals are what let you judge the AI's output. Without them, every suggestion looks equally right.
- Accepting code because it runs. The
loadRatingsexample runs without errors and is still wrong. - Asking for a whole feature at once. Big requests produce big answers that are hard to review. Small steps are easier to check.
- Treating AI as either useless or magic. It is a fast assistant that is sometimes confidently wrong. How to use AI to learn programming faster covers how to use it without skipping the learning.
Quick recap
- AI makes code cheap to produce. Knowing whether it is right is the scarce part.
- Read code line by line, debug with a method, and break problems into small, checkable steps.
- Design judgment means keeping code easy to change, not just making it work.
- Explaining your decisions is a skill teams and interviewers look for.
- Spend less time memorizing syntax and more time writing and fixing real code.
Frequently asked questions
What skills do developers need in the AI era?
The ones AI is weakest at: reading and reviewing code, debugging, breaking problems into small steps, design judgment, and explaining decisions. All of them rest on solid fundamentals, like how data, functions and async code actually behave.
Will AI replace software developers?
It is changing the job more than removing it. More of the work is reviewing, deciding and fixing, and less is typing. Will AI replace junior developers? looks at what the evidence says.
Do I still need to learn to code if AI can write code?
Yes, if you want to build software you can trust. You can't review, debug or change code you don't understand.
Which programming skills should I learn first?
Start with one language and its fundamentals, then learn to work with real data: arrays, objects, async code and fetching from an API. That is what most AI-generated code is made of, and what most bugs hide in.
Practice
The best way to build these skills is to write code, break it and fix it. In Intermediate JavaScript (opens in a new tab), the async section starts with Sync Vs Async (opens in a new tab) and builds up to Handling Fetch Errors (opens in a new tab). The course ends with a project you build step by step. Each exercise works in your browser, so there is nothing to install.
Keep going
Intermediate JavaScript (opens in a new tab) covers the fundamentals that make AI-generated code readable: array methods, async code and working with real data. Once those feel solid, Software Design Principles in JavaScript (opens in a new tab) goes deeper on design judgment.
