<h2>The trap nobody talks about</h2>
Some odd kind of lazy creeps in once AI code assistants enter the scene, worse than just grabbing stuff from Stack Overflow ever was. Pulling lines from an old forum post meant dropping ten at most into five hundred you’d built on your own. The bones were yours. The form stayed clear.
Start typing something for the LLM. Out comes full pieces of code. All running fine at first glance. Everything builds without errors. The checks run green. That new bit goes live smoothly. Yet deep inside hides a tiny mistake. One number too high, one gap unguarded, one moment where timing slips… waiting quietly until twice as many people arrive down the road.
What feels unsettling is not the error from the AI. It’s how easily it can slip past you. A clear weakness all developers have been guilty of one time or another is we just don’t read! We don’t go line by line examining where the AI went right or wrong, If it works we move on. That moment of trust becomes the gap where things hide.
<img src="https://media.daily.dev/image/fetch/s--q2JT0tr3--/f_auto,q_auto/https://media.licdn.com/dms/image/v2/D4D12AQEqy_ok1gMz5Q/article-cover_image-shrink_720_1280/B4DZZ3zDFdGsAM-/0/1745766597968%3Fe%3D2147483647%26v%3Dbeta%26t%3D__9JD2teK0NaV-9GnDAsi7Zk-eduHv9pmW5N15wWvjk?_a=BAMAMiWQ0" alt="vibe debugging meme">
<h2>Practice fades when you walk away from it</h2>
I have been coding for roughly five years. A habit I’ve kept for quite a long time, yet even those habits fade when left unused.
<ul>
<li>Reading docs. Because they shape how you think. Skimming MDN documentation might save time, yet skipping it entirely trades understanding for speed. Questions deliver replies fast, true. But answers lack structure without context built from reading. Grasping systems beats grabbing outputs every single time.</li>
<li>Debugging from first principles. Start at zero every time. When the stack trace shows up, when reading gets skipped, pasting takes over. A dopamine rush in from the instant results kicks in. Fixing happens through the AI, not me. Understanding the real breakdown never quite lands.</li>
</ul>
Architecting from a blank file. Starting fresh, no template in sight. Can you recall building something new without copying a starter guide? Ever draw system and plans by hand, pick the wrong path, then spend hours untangling it?
these are all mistakes I have made probably dozens of times. It’s almost like the project is actually finished… does it even matter to me anymore?
<h2>The calculator test</h2>
What matters is how you see it. Knowing math first means a calculator just speeds up number crunching, leaving room to think about real questions. When someone in finance opens Excel, effort shifts from manual steps to decisions. The tool handles repetition while the mind weighs choices.
A child at twelve might skip long division entirely, relying only on a calculator instead. Yet without that practice, grasping multiplication becomes shaky ground. Estimation slips beyond reach. Mistakes multiplying by ten go unnoticed - simple errors hiding in plain sight.
Here’s the thing about AI. Suppose you understand databases well enough to set up one yourself (even with a BaaS). Asking AI to draft it feels like using a calculator. Now imagine never having defined a schema, set up the sdk and added the server side queries yourself. Just copying and pasting instructions from chatgpt or if you are using a CLI too, not even that! Now you’re unable to describe how inner logic works, yet sending AI-made queries straight into live systems. You might have never even read the documentation for the system you’re using. That leans on a crutch. Over time, leaning means the muscle fades.
<h2>Habits that keep us sharp</h2>
Nothing here changes the world. Just doing what must be done.
Read every line the AI generates. Start at the beginning, go line by line. Skip nothing. When something feels off, pause. A strange name? Search it. Google is your friend here. An odd structure appears? Stop. Do you understand what the code is actually doing? See each result like code handed down from someone skilled, yet cautious. Believe parts of it, question the rest.
Build something from scratch every month. Without help from Copilot. Not using Claude. Autocomplete limited to basic editor support. (I turned off my AI autocomplete ever since i switched from VScode to Zed) Choose a tiny project, maybe a command line app. Or a little desktop tool with Tauri. Perhaps a quick site made with SvelteKit over two days. Notice how hard it gets sometimes. The struggle shows up. Good. That’s where it matters.
Own your architecture decisions. Decisions about structure belong to you. Letting AI choose your tools (database, framework, destination) can haunt later days. For small coding tasks, assistance makes sense. Big moves shape long-term paths. Write down why you picked what you did. Ownership means standing by choices, clearly explained.
Rubber-duck the AI’s code. Start by talking through the AI’s output like you’re telling a friend. Say it aloud or type it into a note before saving any changes (I talk about it to myself in the shower). When words won’t come, that means clarity hasn’t arrived. Hold off on saving until understanding lands. If meaning stays foggy, the work isn’t ready.
<img src="https://media.daily.dev/image/fetch/s--PQi2WDtc--/f_auto,q_auto/https://miro.medium.com/v2/resize:fit:800/format:webp/1%2A3NajV0NlFiy3imrkDje-fQ.jpeg?_a=BAMAMiWQ0" alt="read the docs meme">
<h2>Warning signs you’re already cooked</h2>
If one of these fits how you feel right now, maybe today is the day to start fresh instead:
<ul>
<li>You can’t remember the last time you opened official documentation</li>
<li>Your first instinct when seeing an error is to paste it into a chat, not read it</li>
<li>You’ve shipped features where you’d struggle to explain the logic to others</li>
<li>You feel genuinely anxious coding without AI assistance</li>
<li>You’ve stopped noticing when the AI suggests something subtly wrong</li>
</ul>
Spotting poor code comes from experience. I wouldn’t consider myself an expert per se besides, I am only 15 years old. After spending countless hours reviewing both clean and messy examples, your instinct sharpens. Skip doing the reading yourself? That gut feeling fades fast.
<h2>The honest take</h2>
In our industry at the very least, AI is not vanishing any time soon, and if you completely ignore AI you’ll be left behind fast. You should know that what makes us matter as engineers isn’t typing prompts; it’s the gut sense for flaws, choices under pressure, out-of-the-box thinking, and most important of all: our Humanity Years may pass while i master my skills slowly. Should I quit now, those habits will fade away.
Use AI as a too, not a crutch. Thanks for your time.
-Xavier Womack

Smiley Face

Xavier Womack

A developer reflects on how AI code assistants can quietly erode core engineering skills — reading documentation, debugging from first principles, and architecting from scratch. The post warns against over-reliance on AI-generated code that passes tests but hides subtle bugs, and offers practical habits to stay sharp: reading every line of AI output, building something from scratch monthly without AI help, owning architecture decisions, and rubber-ducking generated code. The author uses a calculator analogy to distinguish between using AI as a productivity multiplier versus a crutch that atrophies foundational understanding.

So AI is making me Lazy...

For senior developers this shouldn’t be a concern we’ve been there done that got the t-shirt AI is just accelerating the workload where appropriate. What concerns me more is the more junior members of staff never having to learn to trawl through code to find a problem, never having to sit there and try different things to get it working. So when they get to a problem AI can’t cope with they’re completely stuck

This makes sense more than anything else

I’m in my 40s, have been programming professionally for over 20 years (longer as a hobby) and having moved to using AI assistance within the last year I have found this reliance creeping in.
Pasting errors into chat without reading them really hit home for me… For professional development, using AI has increased productivity considerably, as long as there are guards in place. All code is reviewed by both AI and at least one other human. I read through all of my code before committing changes to make sure I understand what’s been done and make sure nothing extra has slipped in.
However I’ve tried to get back into personal projects recently, without using AI and I’ve forgotten how to code… I know the architecture I want for the solution, but getting back into the mindset for actually approaching these issues without coding agents has really knocked my confidence. I’m pushing through and forcing myself to relearn how to “code”, but with the productivity gains of AI, it now feels even slower than it did before…
Great insights in your post and it’s good to see people talking about the downsides without dismissing the benefits of AI assisted development.

This reads like a cope. If you’ve set up your tools right none of this is required.
You can still do all of this, just AI enhanced:
gut sense for flaws, choices under pressure, out-of-the-box thinking

What I am encouraging everyone to keep in mind is that: We do not know the impact of using AI/LLMs on our minds and cognition on a regular basis.
We didn’t understand the impact of Social Media before it was rolled out to the masses rapidly, and now we’re dealing with tremendously negative consequences, from misinformation to attention deficit.
There is already ample evidence now that points to the cognitive impact and atrophy that results from relying on these models and outsourcing our thinking. The rapid integration of AI is very much an experiment with unknown consequences.
Hell, even Anthropic themselves is quoted as:
“One reason that the atrophy of coding skills is concerning is the “paradox of supervision”—as mentioned above, effectively using Claude requires supervision, and supervising Claude requires the very coding skills that may atrophy from AI overuse.”
Personally, I’m pretty moderate in my usage. They mostly just process data and run tasks for me. I still manually code at least 50% of the time, and I keep my <a href="https://confident-coding.com/" target="_blank" rel="noopener nofollow">debugging skills</a> sharp.