Hand Writing Code in an AI World

Coding through Rose tinted glasses.

Coding with AI is the norm now. Prompting a fresh nextjs or laravel install to build me the next uber x tinder saas that can hyperscale seems like the going thing (especially for VC clout). Code quality is out the window, as is design, architecture and care. Don't get me wrong, I am a huge advocate for AI augmented code. The speed in which you can stand something up in a realm you have never played in astounds me to no end. I truly believe running coding agents to design, write and review each others work is the future, but part of that makes me sad. Sad in the sense that the artisanal approach to code will diminish over time. Sad because the feeling of achievement of truly understanding a problem and coming up with an elegant solution will fall by the wayside to an AI path of least resistant solution.

A look back in time

To get perspective, we don't have to look back even 10 years to the rapid change in the way coding has evolved. I started my developer journey back in 2016/17. I was as green as they come, having achieved a mediocre software developer degree with aspirations of conquering the world. With my plethora of 'data structures' and 'sort algorithms' all memorised (only in Java of course), I was ready for my first job as a software developer.

I moved to the UK and (somehow) managed to land a job with a brilliant Drupal agency (Zoocha) just out of London. I was set, nailed the interview, first day, brimming with optimism - and then reality set in - I barely knew how to open the command line. Drupal was caught between 7 and 8 at the time and I distinctly remember sinking hours every day just setting up local development environments (all native). After the environment setup, there was figuring out what to do. Stack Overflow was my best friend as well as anyone in the company who would answer my (very dumb) questions. Those first 6 months were brutal and I am forever thankful for the tolerance/patient that I was showed.

After this teething period, everything started to flow a bit more. I managed to actually read docs/understand requirements. Communication and understanding around issues increased and I genuinely felt more connection with the code. I no longer dreaded issues I didn't know but actually looked forward to the opportunity to solve them.

Landscape of today

Fast forwarding to the reality we have today - I'm not 100% certain I would have survived and fell in love with the industry/art of code. Every solution seems to be turbo charged. This is all fantastic for the end user/business of course. API integrations can be achieved in a day rather a week. New workflows and forms take mere hours and don't get me started on migrations. These are optimal outcomes. A better product for a better price.

The problems I see are in the long term relationship the developers have with the code. Reading docs and understanding an API used to be a point of pride (some call it Stockholm Syndrome but I digress), the inner workings of a language were deemed a developers core value add and if you were rapid, you were viewed as something other than normal.

Since most of these can be offhanded to frontier models upfront, there is no investment for a developer. They lose the connection to the code and when inevitably, bugs start appearing, there is less drive to fix it and fix it well.

We have all seen the study where devs think they are faster with AI than without but this makes sense. When upfront investment is so low, of course there will be a sense of speed. A project is only 50% complete when you have written 90% of the code meaning long tails have and always will be the true time spend in development.

The vibe is shifting

I had this great sense of speed and enthusiasm when I set up a Laravel app to try my hand at some primo Vibe Coding. I have had a bit of experience with Laravel but nothing too intensive and thought I would be able to skip the boring bits - route set up, controllers, models, etc, etc. The problem is that the boring bits are the most pivotal. Controller creation ended up putting full business logic in the routing files, CSS/JS all inline and this is with handrails.

I know this sounds like lazy prompting (which it is) but this is also 90% of prompts developers (juniors especially) will run. The biggest problem was it all worked. I could have let it be and deployed as is but this would be shocking to work with in the future. I had to really get specific on my prompts or just hand write completely which ended up rounding the time back up to a full dev lifecycle anyway. I found it more mentally taxing switching gears, and actually get into weeds as I expected AI to just 'fix' things.

It was fantastic at helping with architecture ideas however. The socratic method to set things in motions was a huge winner, but in the nitty gritty, I am not sure how much I actually got.

"Working" and "understanding" aren't the same thing.

Recent studies paint this picture well of what happens when we outsource our problem-solving to AI.

A 2025 study published in Societies journal examined 666 participants across diverse backgrounds and found a strong negative correlation between AI tool usage and critical thinking scores (r = -0.68). more AI use leads to more cognitive offloading, which inversely correlates with critical thinking ability (r = -0.75).

Microsoft Research's 2025 study at the CHI Conference found something equally revealing: higher confidence in AI tools is associated with less critical thinking, while higher confidence in one's own abilities is associated with more critical thinking. The tools we trust determine whether we engage our minds or let them atrophy.

Perhaps most intriguing is that research shows over 50% of AI-generated code snippets are integrated without modifications. Developers are accepting solutions they haven't fully examined, creating what researchers call an "illusion of competence" - we think we understand code we didn't write and mental models we didn't build.

This resonates heavily with me as I can feel the cogs struggling to turn when going from an AI heavy code session to properly debugging/hand-writing.

The Real Cost Isn't What You Think

The narrative is that "AI will replace developers" or certainly thin out the field but I don't think that's the true danger.

The danger is that developers will replace themselves - not by losing their jobs, but by losing their agency. By outsourcing all decisions to tools that don't understand context, trade-offs, or long-term consequences. Even company dynamics and industry trends need to come into play.

My Laravel routes file is the perfect example. The AI's solution wasn't wrong in the sense of being broken. It was wrong in the sense that it violated separation of concerns, made testing harder, and would become unmaintainable as the codebase grew. Those aren't bugs the AI could detect - they're structural problems that require understanding the system as a whole.

When you stop hand-writing code, you stop building the mental models that let you make those judgments. This is especially important in juniors as they create and grow. The next generation of developers will be ones with AI on full blast from day one. More powerful but certainly more trigger happy.

Skill erosion isn't dramatic. It's not suddenly forgetting how to code. It's the gradual acceptance of solutions you don't fully understand. It's shipping code that works today without considering whether you could explain why it works or fix it when it breaks tomorrow.

It's losing the ability to optimize in the right places because you never developed the intuition for where optimisation matters.

The Joy of Understanding

The rose tinted glasses of hand-writing code can quickly become nostalgia. The 2 day debugging session was objectively terribly and I never want to set up local dev environments without docker again. It's the satisfaction of truly understanding your craft that is the winner here. I know now it is quicker and easier to create (with AI), as the profession has changed admittedly for the better.

But when you write code by hand, you care about it differently. You are deliberate with variable names, file structure and especially loop length. You are a reflection of the code and that means something. You understand trade-offs because you're making them consciously rather than accepting them from an AI.

The Japanese have a brilliant word for being a master of your craft - Shokunin (職人). This is someone who dedicates their life to crafting optimal solutions in their given field. With AI, it is easy to lose this and rely on Claude or ChatGPT. I believe you should never stop working on your craft, no matter how extracted.

The one who will thrive in this environment aren't those who can write the most code the fastest. They're the ones who know when to write code by hand and why it matters. They're the ones who maintain agency over their architectural decisions. They're the Shokunins.