I'm a senior developer. I work on a neural net for a living. I spend my days elbow-deep in the thing everyone else uses to avoid thinking, and from where I'm sitting, I can tell you exactly how the trick works, because I helped build the trick.
Here's the pitch AI was originally sold on: ask a question, get a fast answer that actually fits what you needed. Need something built quick? Get a working solution. Simple, right? Except the direction this thing is actually moving in now makes that pitch feel almost quaint.
Constantly asking the model to do it for you is, undeniably, a pretty great feeling. You sit there with your coffee, enjoying your life, and the robot handles it. Then, later, you're chasing down a pile of bugs you don't understand, because you have no idea what it actually did in there. It just did something. And now it's your problem.
Everything has upsides and downsides, sure. But I'm the type who notices the downsides first. Somebody once pitched me a deal recently — pay for one, get a second one free — and I was out the door before they finished the sentence. I thought that's how a normal, honest offer sounds. Turns out I was wrong about that too.
Anyway. I went on vacation. Brought my laptop. Set the agent running before I left the room, went and did vacation things, came back, clicked "Keep changes," and went right back to relaxing. What I got back was a service that technically worked, held together with duct tape and vibes, but working. And that's the trap, because it is genuinely great. It's also, functionally, a drug. You get used to it. At some point you notice you can't really work without it anymore. You've become a hostage of the system you were supposed to be commanding.
The Part Where I Tell You to Try It Yourself
How long have you actually been leaning on an assistant for your real projects? Go ahead, tell yourself: "I remember everything, I don't need it, I could spin up a whole SaaS from scratch in two weeks." Great. Do it. Actually do it — no assistant, no autocomplete, no "explain this error for me." Hard? There's your answer.
However uncomfortable it is to admit, a huge number of us have quietly become hostages of these tools. And I think there's exactly one way out, so let me just hand it to you straight, because dancing around it wastes both our time.
Use the model as an absurdly overpowered search engine. Nothing more. It was trained on an obscene amount of accumulated knowledge — use it to retrieve that knowledge, not to think for you.
Stuck on how to implement a specific algorithm? Don't ask it for the code. Ask it to walk you through how the algorithm works, step by step, like you're explaining it to someone who's never coded a day in their life. Something like: "Explain how this sorting algorithm works like I'm five." Then go implement it yourself. You solve the problem — the model just handed you the missing piece of context.
Hit an error? Paste it in, not so the model fixes it for you, but so it explains why it's probably happening. Then you go dig, you go think, you go verify. You do not let it hand you the patch.
Don't let your brain clock out. I've spent a fair amount of time reading into neuroscience and how the brain actually operates, and here's the uncomfortable summary: it's lazy by design. The second you give it permission to coast, it will take that permission and run with it, all the way to zero.
Turns Out I'm Not Being Dramatic, There's Actual Data on This
I'd love to tell you this is just my personal hot take. It isn't. MIT's Media Lab ran a study in 2025 called "Your Brain on ChatGPT," and it's the closest thing this argument has to a smoking gun. Researchers split participants into three groups — one wrote essays using only their own brain, one used a search engine, one used an LLM — and tracked them with EEGs across four sessions. The LLM group showed measurably weaker neural connectivity, worse memory of their own writing, and the lowest sense of ownership over what they'd produced. A chunk of them couldn't even accurately quote their own essay back five minutes after writing it. The researchers gave this pattern a name that deserves to stick around: cognitive debt. Like technical debt, except the interest gets paid in your own ability to think, and there's no refinancing option.
Then there's the plot twist buried in the same study, and it's the one that actually matters for anyone reading this on a dev blog: the group that started writing unaided, then brought in the LLM to revise, ended up with the strongest brain-wide connectivity of anyone in the study. The group that started with the LLM and later tried to work alone struggled to activate those same networks at all, and produced writing the researchers described, bluntly, as "linguistically bland." Sequence matters. Struggle first, assist second — not the other way around.
Now zoom out to what's happening specifically to developers, because it's not subtle. Stack Overflow, sixteen years as the default place programmers went when stuck, has effectively collapsed. Monthly question volume fell from north of 200,000 at its 2014 peak to under 50,000 by late 2025, dropping the platform back to question levels it hadn't seen since 2008. Fifteen years of accumulated community knowledge-sharing, undone in about three years, roughly tracking the release of ChatGPT and the mainstreaming of Copilot. And here's the part that should actually worry you more than the traffic graph: Stack Overflow's own 2025 Developer Survey found 84% of developers now use AI tools daily or near-daily, while 46% of them openly say they don't trust the accuracy of what it gives them. Only 33% report trusting the output at all. Among experienced developers specifically, that trust number drops even further. We are, as an industry, mainlining a tool the majority of us admit we don't actually believe.
And the code itself is quietly rotting while this happens. GitClear's longitudinal analysis, tracking hundreds of millions of lines of changed code from 2020 through 2026, found refactored or moved code — the stuff that indicates someone actually revisited and improved existing logic — dropped from roughly a quarter of all changes in 2021 to under 10% by 2024. Copy-pasted code, meanwhile, overtook refactored code for the first time in the dataset's history, and duplicated code blocks rose eightfold in a single year. Code churn — code getting rewritten or deleted within two weeks of being written, a decent proxy for "this was never actually understood in the first place" — roughly doubled. The throughput numbers look fantastic in a sprint report. The maintainability numbers look like a codebase quietly accumulating a mortgage nobody's making payments on.
So What Do You Actually Do With All This
Honestly, I'll still tell you to go dig through forums and books the old-fashioned way when you can. But let's not pretend that's realistic as your entire strategy anymore. It isn't, and telling you otherwise would just be a different flavor of dishonest. What's realistic is adapting on purpose, instead of drifting into dependency by accident:
- Ask for explanations, not deliverables. The moment your prompt is "write this for me" instead of "help me understand this," you've swapped a learning opportunity for a dependency.
- Struggle first, assist second. Per the MIT data, this single ordering choice appears to be the difference between the tool strengthening your thinking and quietly replacing it.
- Treat every AI-generated error fix as a lead, not an answer. Read what it says happened. Go verify it against the actual system. Don't just paste and pray.
- Notice when you've stopped being able to explain your own code. That's not a productivity milestone. That's the cognitive-debt collector showing up at your door.
- Occasionally build something with the assistant switched off entirely. Not as a purity ritual, as a diagnostic. If it feels impossible, that's useful information about where you actually stand.
None of this is anti-AI as a stance, and I'd be a hypocrite to pretend otherwise given what I do for a living. The tool is extraordinary at what it's actually good at: compressing the time between "I don't know this" and "I understand this." The failure mode isn't the tool. It's letting it compress the distance between "I don't know this" and "I don't have to know this" instead — because that's the version where you wake up one day, mid-career, capable of shipping a working app and completely unable to explain how it works. And in this industry specifically, that gap doesn't stay invisible. It shows up exactly when you least want it to: in an incident at 3 AM, in an interview, in the one moment nobody's around to prompt the model for you.
