The worry we got wrong

Here is a story from an article by developer Michael Lawrence, and it stuck with me. A senior developer reviews a pull request. An AI coding assistant (Claude Code) has refactored about 400 lines of code. The diff looks clean. Tests pass. The developer approves it.

Two days later, a bug shows up in production. Someone digs in and finds it: in the 400 lines, a null check quietly disappeared. The refactor looked right, the tests were green, and the safety net was gone without anyone noticing.

The developer missed it. Not because they are bad. Because the AI-generated code no longer required them to look. The code looked good, so their eyes stopped looking.

This is the story nobody tells in the "AI replaces developers" debate. It is not about losing your job. It is about losing your edge, one approved pull request at a time.

Deformation, not replacement

Think of the skills you use to write software: reading code, spotting bugs, noticing patterns, knowing where to look when something feels off. These are not magic. They are muscles, and like every muscle, they are built by resistance.

For years, that resistance was built into the job. You read the codebase carefully because there was no one else to read it for you. You debugged because there was no shortcut. You wrote each line, and each line taught you something.

Now AI absorbs the resistance for you. It writes the boilerplate. It explains the error before you read it. It refactors 400 lines while you skim the diff.

Friction was the lesson. AI quietly removes friction at the exact moments where you used to learn.

The three shapes of deformation

Depending on where you are in your career, the pressure bends you differently.

Juniors: they never form

A junior developer's first year used to build foundation skills: reading code, thinking through logic, making mistakes and fixing them. Those mistakes are the curriculum. They are slow, and embarrassing, and exactly how your brain learns.

A junior who starts with AI never makes those mistakes. They type a prompt and the code appears. The first time they must debug a real system, they have no map. They have never seen the failure states that build intuition. It is not that AI replaced them. It is that the developer never got formed — and nobody notices until the training wheels are gone.

Mid-levels: arrested formation

Mid-level developers are the group squeezed the hardest. Their skills are real but not yet automatic. Every task they hand to AI is a task they do not fully practice — and this is the exact stage where practice was still turning them into seniors.

They do not unlearn. They just stop forming. Five years pass, and the gap between their level and the level they were supposed to reach grows quietly.

Seniors: atrophy

Seniors do not need AI to learn. They need AI to notice things. The story above — the missing null check — is a senior-shaped mistake. The skills are there, but the attention is gone. When code arrives already polished, nothing forces you to look closely.

Skills at the senior level are maintained by use. AI gives them less to use. The sharpness fades in a way that is impossible to notice from the inside.

You lose what you stop practicing

None of this means you should throw your laptop into the sea. The mistake is not using AI. The mistake is using AI as a replacement for thinking, instead of as a tool that works around your thinking.

The people who stay sharp in the AI era do not refuse the tools. They build a routine around them:

• Triage by skill. Hand AI the work you have already mastered — boilerplate, glue code, migrations you have done a hundred times. Keep for yourself the work that is still forming you. That is where the practice is.
• Let AI write, but review like you wrote it. A generated diff must be read with the same suspicion as your own code. If you would not approve your own 400 lines without reading them, do not approve the machine's.
• Make your rigor external. Since attention fades, push rigor into tools that never get tired: unit tests, type checks, code review checklists, eval scripts that test the code you generate. The safety net the senior missed can live in the CI pipeline.
• Practice deliberately, away from the machine. Rebuild a small feature by hand. Read code with AI off. Pair with a human. Keep a part of your week where the thinking is all yours.
• Notice the squeeze. Ask yourself honestly, once a month: what could I still do if the AI disappeared tomorrow? If the answer shrinks, cut back the prompts.

Friction was the lesson. Stop removing all of it.

The hard parts of coding were never a bug in the job description. They were the job. The confusion, the bad first drafts, the hour spent chasing a bug that turned out to be one missing line — that was the tuition, and you paid it in time.

The danger of AI is not that it makes you faster. It is that it makes you faster by deleting the parts that made you better.

The thing that actually replaces you

Here is the uncomfortable truth. AI might never replace a developer. But a developer who has quietly stopped practicing, stopped reading carefully, and stopped thinking hard — that developer can absolutely be replaced. Not by a machine. By a version of themselves who kept their edge.

The article's author said it plainly: you do not lose what you already learned. You stop adding to it. And a skill that stops adding stops growing, and a skill that stops growing starts dying.

Naming it is the first step

The "AI replaces developers" panic is loud, and it is the wrong conversation. The real conversation is quieter: your code gets written for you, and it is written too well for you to bother looking.

AI is a tool, and it is a good one. But every tool has a cost, and this one is paid in attention. Use it. Enjoy it. Ship faster. Just never let it read the code instead of you.

Because the developers who survive the AI era are not the ones who used the most AI. They are the ones who still know how to think, and who made sure the tool never thought for them.