Your AI coding assistant is making you a worse programmer. No, seriously—Anthropic just confirmed that the tool you’re using to ship features 50% faster is also the reason you can’t whiteboard a binary search tree anymore. But sure, keep letting Copilot write your useEffect hooks. What could go wrong?

Anthropic dropped a research paper recently that confirms what your imposter syndrome has been whispering: AI coding assistants are creating a generation of developers who can ship fast but think slow.

The study found that developers using AI assistance complete coding tasks significantly faster (shocker), but here’s the kicker—they demonstrate markedly lower skill retention and problem-solving ability when the AI is removed. It’s the cognitive equivalent of using a GPS for every drive: sure, you get there, but try navigating your own neighborhood without Siri and suddenly you’re lost in a cul-de-sac of your own making.

The Research in Plain English

Anthropic’s team had developers tackle coding problems with and without AI assistance. The AI-assisted group crushed it on speed. But when tested on conceptual understanding and asked to solve similar problems solo later, they performed worse than the control group who struggled through manually.

The effect was asymmetric: senior developers maintained their skills (the AI just made them faster), while junior developers showed significant skill degradation. The AI wasn’t augmenting their cognition—it was replacing it.

The Uncomfortable Truth Nobody’s Talking About

Here’s where I stop sugarcoating: Current AI tools are designed by experts, for experts, but marketed to beginners.

When you’re a senior dev with 10 years of pattern recognition, AI acts like a really smart autocomplete. You know when it’s hallucinating. You understand the trade-offs of that regex it just suggested. But when you’re a junior? You’re not pair programming with a senior—you’re copy-pasting from a confident idiot that writes elegant-looking garbage.

The research exposes what I call the “Skill Convexity Problem”: AI flattens the learning curve so aggressively that you never build the mental muscle to handle complexity. You’re not learning to code; you’re learning to prompt. And when the AI inevitably hits a wall (complex debugging, architectural decisions, performance optimization), you’re standing there with atrophied debugging skills and a blank stare.

The Flaws in the Current Approach

Let’s critique the research too, because nothing’s perfect. The study measured short-term task completion, not long-term software maintenance. It didn’t account for the “scaffolding effect”—maybe juniors struggle initially but catch up later? (Spoiler: probably not, but we don’t know.)

More importantly, the research treats all AI assistance as monolithic. There’s a difference between using AI to generate boilerplate TypeScript interfaces and using it to architect your Convex schema. The former saves time; the latter steals thinking.

Outside-the-Box Solutions (Because “Use AI Less” Isn’t Helpful)

Since “just code without AI” is about as realistic as “just use vanilla JavaScript,” here are some actually useful alternatives:

1. The Socratic Rubber Duck Mode
Build (or demand) an AI assistant that refuses to give you code until you’ve explained your approach. Force it into a “question-only” mode: “Why do you think you need a useEffect there? What dependencies are you tracking?” If AI is going to be your pair programmer, make it an annoying, pedantic senior dev who cares about your growth.

2. Skill-Debt Tracking
We track technical debt. Why not track skill debt? Every time you accept an AI suggestion without understanding it, log it. Weekly review: “I let AI write 15 regex patterns this week and I understand 3 of them.” That’s your learning queue for next week.

3. The “Ghost Protocol”
Set a timer. After 30 minutes of AI assistance, the AI “ghosts” you for the next task. Force yourself to implement the next feature using only what you learned (or think you learned). It’s interval training for your brain.

4. Pedagogical Constraints
Use AI, but constrain it intentionally:

• Ask it to solve the problem using only concepts you already know
• Have it generate three solutions: elegant (but complex), readable (but verbose), and “junior dev” (what you’d write). Study the gaps.
• Force AI to write intentionally broken code for you to debug. Active learning > passive consumption.

5. The Convex Recovery Method
Since you use Convex (shoutout to your stack), leverage it for skill tracking. Build a personal knowledge graph that tracks which AI-assisted code you actually understand. If you can’t explain the reactive query you just wrote, it doesn’t get committed until you can.

My Thoughts & Analysis

The scariest part of this research isn’t that AI makes us slower thinkers—it’s that it makes us unaware that we’re slower thinkers. The Dunning-Kruger effect on steroids.

As someone who ditched research because “books are boring,” you should be particularly worried. AI is the ultimate boredom-killer, but learning requires productive struggle. The “aha!” moment comes from wrestling with the problem, not from reading the solution. Anthropic’s data suggests we’re outsourcing the struggle, which means we’re outsourcing the expertise.

But here’s the contrarian take: This isn’t AI’s fault; it’s our implementation. We built AI to be a crutch because our industry prioritizes shipping features over developing humans. The solution isn’t less AI—it’s smarter AI. We need AI that intentionally creates friction for learning, not just velocity.

The research also misses the meta-skill: prompt engineering is a skill, just a shallow one. It’s like learning to use a calculator when you don’t know math. Useful, but brittle.

The Bottom Line

Your AI assistant isn’t evil, but it is a terrible teacher. It’s a performance enhancer, not a protein shake. Use it to lift heavier weights, not to avoid going to the gym.

If you’re a junior dev reading this: set boundaries. Use AI for syntax, not logic. For boilerplate, not architecture. If you can’t whiteboard what the AI just wrote, you don’t own that code—you’re just leasing it from an LLM that might hallucinate away tomorrow.

Ship fast, but learn faster. Otherwise, you’ll be a “Senior Developer” who can’t code without an internet connection, and that’s not a senior developer—that’s a prompt engineer with imposter syndrome.