You Haven't Lost Your Skills. You've Just Stopped Wanting Them Back.
The debate about AI causing skill loss is a distraction. The more significant shift is cognitive — developers who truly adopt AI-augmented workflows don't lose their skills, they reprioritise them.
There's a recurring post format on LinkedIn that goes something like this: "Developers who use AI are losing the ability to write code." It gets a few hundred reactions, mostly from people who've either never used AI tools seriously or who used them badly and are now rationalising the experience.
I've noticed I'm compelled to comment every time I see one.
Not because the concern is entirely wrong — there's a real phenomenon being pointed at — but because the framing is so consistently off that it obscures something much more interesting happening underneath.
The Skill Loss Debate Is the Wrong Conversation
The question people are arguing about is: does using AI cause developers to lose coding ability?
The evidence from developers who've actually crossed the threshold into genuine AI-augmented workflows suggests the answer is mostly no. The knowledge doesn't disappear. The mental models, the pattern recognition, the architectural instincts — these persist. They're more like riding a bike than conjugating a foreign language.
But here's where the critics have a point worth taking seriously: there are actually two different things being conflated under the label "coding skill."
The first is the capacity to think in code — to decompose a problem, reason about structure, evaluate a solution. This is durable. It's a mode of thinking more than a set of muscle memories.
The second is production-grade execution fluency — the ability to consistently write clean, idiomatic, edge-case-aware code at pace in an unfamiliar codebase. That one does fade with disuse. Not completely, but enough to matter. Any developer who's come back to hands-on work after a stint in management will recognise the feeling of being slower than they expect to be, more uncertain, more likely to miss things they'd normally catch on instinct.
So the skill loss camp isn't imagining things. They're just diagnosing the wrong condition.
What's Actually Happening Is More Interesting
Eight months ago, I thought of AI as a useful chat interface. A quick way to get unstuck, generate a boilerplate, look something up without switching context. Helpful, occasionally impressive, mostly supplementary.
That's not how I think about it now.
The shift happened gradually and then all at once. At some point I noticed that when I approach a coding task, my first instinct is no longer to open my editor — it's to open a conversation. Not because I can't write the code, but because framing it as an AI-assisted task from the start produces better results faster. The manual approach hasn't disappeared; it's been reclassified. It's still there as a fallback, a sense-check, an override mechanism. But it's no longer the default.
That's not skill loss. That's a change in cognitive hierarchy.
The analogy I keep coming back to is what happened when I moved into management in an earlier part of my career. I stopped writing production code daily. Did I forget how to code? No. But I became slower, less fluent with current tooling, less confident about edge cases in frameworks I hadn't touched in a while. The mental model was intact; the execution muscle had softened.
The difference with AI augmentation is that the execution gap doesn't open in the same way — because the tool fills it. The question is whether that's a feature or a bug.
I think it's a feature, with one important caveat.
The Caveat: This Only Works If You Stay in the Loop
The developers who are genuinely losing capability aren't the ones using AI heavily. They're the ones using it passively — copy-pasting outputs without reading them, accepting first drafts without interrogating the approach, treating the tool as an oracle rather than a collaborator.
That pattern does produce skill atrophy. Not because AI is toxic to the brain, but because passive consumption of anything produces atrophy. It's not an AI problem; it's a learning hygiene problem.
The developers who are thriving in AI-augmented workflows share a particular characteristic: they've shifted from being executors to being directors. They're applying their pattern-thinking and architectural instincts to guide, evaluate, and refine AI output rather than to produce every line themselves. The cognitive load has moved upstream, toward problem definition and solution assessment, and away from implementation mechanics.
That's a real change in what "doing the work" means. But it's not a loss — it's a reallocation.
What This Means for How We Think About Seniority
There's a harder implication here that the LinkedIn debate never quite reaches.
If execution fluency matters less as a day-to-day requirement, then the traditional proxies for seniority start to break down. Years of hands-on coding. Framework depth. Language-specific expertise. These have always been rough signals for the thing that actually matters — the ability to make good technical decisions under uncertainty. They just happened to correlate with it reasonably well.
That correlation is weakening. A developer with strong architectural instincts and genuine AI orchestration ability can now produce output that would previously have required years of framework-specific experience. Meanwhile, a developer with deep implementation skills but poor judgement about when to use what will increasingly be outpaced, regardless of how cleanly they write code.
The industry hasn't fully recalibrated its hiring and evaluation frameworks around this yet. Most job specs still read like they were written in 2019. That gap will close, and when it does, the developers who positioned themselves as orchestrators and decision-makers rather than implementers will be considerably better placed.
So Have You Lost Your Skills?
Probably not. But you may have stopped practising them in a way that means they'll need dusting off if you ever need them in earnest again.
More importantly, that might be completely fine — because the more useful question isn't whether you can still write code manually. It's whether you've genuinely made the cognitive shift from implementation-first to direction-first thinking.
That shift is what separates developers who are riding the AI wave from those who are being carried by it. And it's a much harder thing to fake than remembering how to write a for loop.
The skill you actually need to protect isn't the one everyone's arguing about.