I think for AI to become useful while minimizing it's harm, the interface as a whole needs to be reworked. Instead of having a loop of code generation followed by review. The initiative should be taken by the developer, AI should be a background thing, not one that's surfacing itself to the developer.

For instance I was thinking of AI coding where the developer is writing the application interface, files, design, and the AI in the background is reading them and translating them to the programming language of choice.

This way the developer is writing the whole thing out by hand, it would be as if one is writing fluid pseudo code, but the abstractions would be there, the way they are interacting with each other is there, the human is thinking if the abstractions and when to use them. Whereas the AI is out of the view, simply translating the fluid pseudo code to a rigid programming language.

Perhaps the above isn't really it, but I strongly feel something needs to change in the way we currently work, because it really creates a chasm between the developer and the outputted code not only in terms of the actual implementation but the mental abstractions it's supposed to reflect

Writing code by hand and managing the mental model of its execution and architecture is one of the few remaining joys of my day job, apart from delivering a good product people want and use and being helpful. Even the small things, the tedious chores of refactoring or scaffolding that initial bit of CRUD boilerplate are steps that matter to me. The callouses matter. The tedium matters. These moments of pain and drudgery inform me on what to do differently next time in a way I worry I would not appreciate otherwise, were specific tools thrust upon me.

I remain because I remain hopeful the pendulum will swing the other way someday.

really good piece, sums up almost exactly where I'm at with AI currently.

cognitive debt is a real problem in my domain (embedded software) because AI simply can’t debug the symptom when the reasons for the bug aren’t in code, and a stack trace may not exist. finding the REALLY hard bugs requires in depth systems understanding and the ability to connect things you’ve seen around the codebase together - and the fix usually isn’t adding code, which means the patchwork fixes Claude likes to do only makes things worse.

that said, it’s made writing harnesses and supporting tools WAY easier and faster, and my workflow is better for it. Searching the git history for the why of things is also made way easier; helping me to reason more effectively

Hi HN, I've been using Claude Code heavily for the last year. Recently I've noticed a shift in sentiment among peers, here on HN, and over on /r/ExperiencedDevs. I wrote down some thoughts on the hidden costs of using AI too much that are not obvious, yet there's no concrete data yet. I tried to pull together data from a few different places to articulate something I think a lot of us are experiencing right now. I'd love to hear your thoughts

The hell with with whatever speed boost I might get. I still write all my code by hand every day, and own what it does. I know it. And I don't have to worry about atrophy.

Could've outsourced a long time ago to humans, if I wanted to deal with reading code most of the time instead of writing it.

This is a wonderfully balanced and accurate take. I have been looking for the right medium of using AI to assist me. Cannot agree more on the three patterns to implement and there to avoid.

If the three good patterns are adhered to, these AI tools can help us become more knowledgeable, productive.

We get to retain our cognitive abilities and the desire to pursue code development as a means to solving hard problems.

Adopting the anti-patterns, on the other hand, could lead to over-reliance on AI, anxiety when the tools go down (this happens! ), the atrophy of ability to debug and the yearning for immediate gratification and quick fixes.

Most insidiously, when code inevitably fails in production on cases the developer should have reasoned about and covered, they have no option but to toss it back to the AI tool, thereby, creating a vicious cycle of anxiety, helplessness and cognitive decay.

I have a few parallel AI-authored side projects on the go that have quite different shapes, and I feel quite different things about each

1. A survival horde game (like Vampire Survivors and Brotato). At the moment it's very primitive, very derivative (no new ideas) and not much fun. I have no sense of pride over it, but it is much further along than it would be if i'd been writing it from scratch. I expect once I invest in the fun side (gameplay innovations, graphics) i'll feel a greater sense of attachment, and I plan to do all the art assets myself.

2. A MacOS web app for managing dev env processes, works but is ugly. I don't have confidence in AI making a remotely presentable UI, so I'll be doing that part myself.

3. A useful little utility library. The kind of thing that pre-LLM would've been too far out of my expertise to be motivated to try making. I'm steering the design of it quite heavily, but haven't written any code. It seems like it's already capable of doing very useful things, and I oddly feel quite proud of it. But I have a weird sense of unease in that I _think_ it's good, but I don't _know_ it's good.

I think the main thing I'm learning is to make sure there's always something of yourself in whatever you produce with the help of AI, especially if you want to feel a sense of accomplishment. And make sure you have a good testing philosophy if you're planning to be hands-off with the code itself.

I started my coding apprenticeship back in early 80s with a senior programmer who taught me to code in LSI-11 processor codes. I memorized the whole table of octal processor opcodes and learned how to compose them with data to write programs on PDP-11. I was able to understand what each exact 16-bit word in my program is doing. It was a great skill. But then the same guy taught me FORTRAN 83, and I suddenly understood that writing in opcodes is not exciting anymore, because you can be 10x more productive and suffer less. Now, many years and programming languages later, with my coding skills in LSI-11 opcodes totaly athrophied, I do not regret about loosing that skill at all.

I see no reason to regret that our skills in coding C++/Java/* will decline or athrophy at some point in time. This will mean that we just don't need them anymore.

> Boilerplate and scaffolding

Have we really reached the limit of how much we can reliably automate these things via good old metaprogramming and/or generator scripts, without resorting to using unreliable and expensive statistical models via imprecise natural language?

> Refusing to use AI out of principle is as irrational as adopting it out of hype.

I'm not sure about this. For some people, holding consistently to a principle may be as satisfying, or even necessary, as the dopamine hit of creation mentioned in the article.

Your writeup accurately captures the big concerns I have about using AI coding tools. One extra thing I have noticed around this is I have a similar feeling about driving and self driving. I really love driving but since I was able to better arrange my life and no longer am a commuter driver I don't get as much daily practice so now when I do take the occasional long drive I don't have as much skill and expertise. It is the same with AI coding tools, I need to put them down from time to time and exercise my mental sharpness to prevent losing my abilities to be a senior engineer.

Coming at this from the opposite end...I started coding 8 months ago with no experience, so AI assistance isn't replacing skills I had, it's the reason I have any skills at all.

But I've noticed something similar to what you describe. When Claude writes a solution for me, I understand it about 70% of the time. That other 30% used to bother me and I'd dig in. Lately I catch myself just accepting it and moving on. The velocity is addictive but you're right that something is being traded away.

The cost I've started noticing most: I'm worse at holding the full architecture of my own app in my head than I should be 8 months in. I can describe what each piece does but I couldn't rebuild it from scratch without help. Not sure the version of me who learned without AI would have that problem.

Still wouldn't trade the tradeoff = I have a live production app that wouldn't exist otherwise. But it's an honest cost worth naming.

I recently accepted-ish a position at a very ai-forward company. Manual programming was somewhat discouraged entirely.

I've used AI tools in the past for maths I didn't understand or errors I couldn't make sense of, and wrote the bulk myself, but now we have as mentioned, opus/sonnet 4.5- which work great.

As part of this, I had to integrate two new apis- nornally, when I write an API wrapper I end up learning a lot about how the API feels, what leads to what and how it smells, etc. This time? I just asked Claude to read it's docs, then gave suggestions about how I wanted it to be laid out. As a result? I have no idea how these apis feel, their models, etc. If I want to interact with them, I ask Claude how I do a thing with the library it made.

Mind you, the library is good. I looked over everything, it's fairly thin and it's exactly how I would write it, as I suggested it do. But I have no deep understanding, much less an understanding of how it got integrated in.

Like, normally when I integrate something in I learn a bit about the codebase I'm integrating it into. Do that enough times, and I understand the codebase at depth, how things plug in. This time? Nada.

It's.... Deeply uncomfortable, to know so little but still be able to do so much. It doesn't matter if I get it to explain it, that's just information that washes off when I move onto the next thing. The reflexive memory isn't built.

All of which is to say, I agree with the article.

In other engineering fields, no one calculates the numbers for building a plane or a dam by hand anymore. They rely heavily on software for design, simulations, etc. throughout the entire development cycle. Yet, starting in university, those engineers still learn to do those calculations by hand so they comprehend the underlying principles.

IMO, that’s what we should do as software engineers. The idea of letting AI "do the thinking" for you is a bad idea. Sure, it can trivially write a sort function for you. Let it! But you still need to understand how that sort function works. If having the tool was a substitute for understanding the fundamentals, anyone with access to Catia, etc. could design a working airplane.

I think it's important to be conscious of skill atrophy, but I don't see a problem with it if what you're offloading to AI isn't your area of focus. For instance, I don't necessarily want to always know what tricks the compiler is using to compile my program, even if they are pretty smart.

The opening sections including graphs do not match my experience. I think they only apply to certain workflows which can be described as "work we have to do because software has a history of poor integration". I.e. repeating solved problems.

Claude will, when given a task off the beaten track, churn through tokens for a while, then produce a completely incorrect answer. (Most recent anecdote: fixing a barostat in an MD sim)

Specifically: How does Spotify, a music streaming service, improve due to AI agents producing code all night? What is improving or being fixed which needs that much abstract code and problem solving? I am guessing the AI code is just building more messy architecture on top of the messy architecture which is causing so much work to be generated.

In the section about Cognitive Debt the author wrote...

Apply this directly to fully agentic coding. If you stop writing code and only review AI output, your ability to reason about code atrophies. Slowly, invisibly, but inevitably. You can’t deeply review what you can no longer deeply understand.

I think this argument is flawed. On every team I've worked with we've always had the opinion that junior developers learn a lot about coding by reading and reviewing code written by other people, especially people more senior to them. Reviewing output doesn't weaken your skills, it improves them. Reviewing code in a large codebase forces you to explore and understand the paths that data takes. It pushes you to build an accurate mental model more than writing new code does, because that's usually isolated to a small, encapsulated domain where you only really need to care about the inputs and outputs (hopefully!).

The author is absolutely correct if you take 'review' to be 'click the accept button and move on', but if you're actually reviewing the code that your AI generates, and understanding it, and thinking about how to move forwards and prompt it to build the thing you really want, then AI only really removes the last type-the-code step. All of the architecture and process steps should be coming from you (maybe from a conversation with the AI during the planning step, but still, not just letting the AI do whatever it fancies.)

What just came to my mind is that the current main selling point of AI, is coder productivity. Some anecdotal experiences from a small agile team:

We had 1 week sprints and our PO had sometimes trouble to prepare enough work for the next sprint. We had 4 week sprints and we often ended up pulling tickets from the next sprint. There was often a mismatch in pace. (Quite funny, the time we had found a balance, management ordered all teams to have the same sprint lengths. They couldn't deal with all the asynchronous, overlapping sprint starts/ends. They choose to forfeit our productivity for theirs.)

So productivity isn't all about coders, it's also about owners / managers / shareholders supplying work. This kind of work is much about communication with several involved parties and researching usecases and features in a very specific context. LLMs can help with parts of it, but at one point there will be a flood of excessive, unverified generic reports and LLMs that again condense them with all the inaccuracies, that managers/owners may drown in a fuzzy mess of LLM bureaucracy. Nuances and importance will get lost in excess.

We often had rather large stories that simply had a small set of bulletpoints, because we already communicated everything in person and they were just reminders for the most important stuff. The importance here is that this reflected the teams agency how we solve things. An LLM can probably not at all provide that currently, as they are always excessive and try to add "helpful" details. They simply cannot pick up social norms and agreements, and prompting them correctly is in my opinion very hard or too time consuming.

LLM assisted coding or vibe coding is all the hype. But I have the feeling that the big realization sets in once all supporting processes are convoluted with AI noise, the peers that used to collaborate are detached and social conflicts and misunderstandings escalate.

That was a nice collection of brief history, links to research and other articles, and original thoughts.

> "You don’t learn to recognize good code by reading about it in a textbook, or a PR. You learn by writing bad code, getting it torn apart, and building intuition through years of practice."

I'd like to point out though, that you also learn by AI producing bad outcomes you are responsible for, and building intuition how it might fail through practice... You also might experience more lessons than you would have if you would have coded manually.

> I’m not anti-AI, I like it a lot. I’m addicted to prompting, I get high from it.

I would suggest leaving the keyboard, going outside and getting some real highs. Perhaps also leave behind all your technology and try to experience a non-connected life.

What is the world coming to when folks get a high from prompting a complex algorithm.

Oh well, it probably proves that “human intelligence” isn’t that complex. It seems fairly simple to simulate.

It’s like walking vs taking bus or car. It’s nice to walk sometimes..

>> That deep, focused, creative problem-solving where hours disappear and you emerge with something you built and understand.

Yea but for how long? Go back and read any code you wrote a year ago and realize it could have been AI that wrote it.

One of the things I have started to realize whilst building apps using AI is that you get a bit indulgent when it comes to features. So in my toy project I wanted all sorts of quality of life bells-and-whistles. If this were a proper enterprise application there would have a been a review and priortization process where the merits would be weighted against the cost. In this case the cost is tokens, so fraction of FTE cost. So I just type and it builds. Whilst this is satisfying I am getting the unnerving sense its not going to be good for me (or the toy app) in the long run.

While I agree with a lot of what this post says, to play devil's advocate for a moment, It's natural that skills we no longer need should be phased out. We should take this as an opportunity to figure out what new skills we need now.

If you're working on a personal project or trying to learn something new, by all means write the code yourself. That's still the best way to do it. But your life should not necessarily revolve around work, and sometimes there is nothing wrong wih caring more about the end product than the process.

This expresses so well the concerns I've had as I've increasingly leaned into using Copilot at work.

The mismatch in time horizons between employers and developers will be so vexing.

At any given time, the profit-maximizing strategy for each employer is to have engineers ship features as quickly as possible. For each employee, it is rational to retain and strengthen skills by avoiding some amount of cognitive offloading.

Most insidiously, the temptation of cognitive offloading for the employee aligns with the profit-maximizing strategy of the employer.

I am a student who will be starting my first job this summer. A lot of what is written in the blog is something I have been feeling subconsciously, the joy is being sucked out of programming and idk if I will even have a job in a few years. Most of my seniors from college tell me that they are just prompting in their jobs.

I don’t know how I will be able to build intuition for code I don’t write just “understand”

What I don't think people are talking enough about yet, is that AI doesn't invent new ways of doing things -- it just predicts the next word based on the materials it was trained on. That means that if a company lets all its coding be done by AI -- that company will be permanently stuck in, say, 2026 -- while other companies will be continuously improving.

> Developers need the dopamine hit of creation. That’s not a perk, it’s what keeps good engineers engaged, learning, retained, and prevents burnout.

Are developers some kind of special creature? or must they simply learn to deal with the complexity of juggling multiple projects, like every other desk job in 2026.

I'm not buying this argument - use it or lose it isn't even true in physical sense - sure if you stop working out you lose muscles/strength - but once you start back up the rate of progression is like 5x.

I like using AI but I also like writing source code and complex configurations. I've been using it a lot for "give me an example on how to do this" but I'm not a big fan of vibe coding.

>Every developer I know uses AI for coding now.

And for blogging too, it seems.

"Anthropic’s CEO predicted AI would write 90% of code within three to six months of March 2025. None of this happened as predicted." – oh it absolutely did happen!

I enjoyed the article, though I do have to pick nits with:

> Software used to be deterministic

Ah, someone fortunate enough to have never coded a heisenbug or trip over UB of various causes.

I've written plenty of well structured, well thought out mostly-deterministic software, then spent hours or days figuring what oversight summoned the gremlins.

(There is one low priority bug I've occasionally returned to over the last two-three years in case experience and back-burner musing may result in insight. Nope. Use gcc, no bug, use clang, bug, always, regardless of O level, debug level, etc. Everything else, all of it far more complex, works 100% reliably, it's just that one display update that fails.)

(It occurs to me that that is a bad example, because it IS deterministic, but none of us can pinpoint the "determiner".)

I wish we reach a point were we expect (as a matter of online etiquette) upfront disclaimers on predominantly AI-generated articles, so that we can save a few seconds and directly get our agents to read and summarize them.

Even when it's not slop, the verbosity of poorly edited AI-generated content is a micro-agression against readers. The prompter expects readers to read what they couldn't be bothered to properly edit.

Pushing AI-slop code without review, and without explicit warnings is a macro-agression against your colleagues, collaborators, and future agents. You are expecting everybody around you to maintain/ refactor, what you couldn't be botherered to review.

A reasoned argument I agree with.

The challenge is that the competitive and economic pressures make this moot.

A person, entering the field via AI driven development, will have none of the qualms about skill, seniority, understanding the codebase, or craftsmanship. Those arguments are handwringing by the previous generation of engineers. Their focus is solely on the outcome and value produced from the input prompt. That aligns closer to how businesses see their codebase: something they have to prompt their engineers to produce in order to generate business value.

Similarly, new AI driven companies focused on delivering value at speed and lower costs will have none of the baggage of the legacy code companies with engineers stuck debating these questions. These new gen companies will be focused on delivering value, doing so at quicker speeds and lower costs, raising the level of competition for existing incumbents.

Will existing businesses be willing to spend money to purchase services from these new gen companies of AI developed products? Seems like it.

There are real problems with these AI developed codebases. They tend to collect baggage and start to feel like a house of cards. A big open question is whether AI models will continue to improve in order to patch all the vibe-holes being generated. Seems like they will improve.

There's another great comment by daxfohl that I saved. The "complacency" at scale worries me [1]

Copied to save you a click:

> I worry about the "brain atrophy" part, as I've felt this too. And not just atrophy, but even moreso I think it's evolving into "complacency". Like there have been multiple times now where I wanted the code to look a certain way, but it kept pulling back to the way it wanted to do things. Like if I had stated certain design goals recently it would adhere to them, but after a few iterations it would forget again and go back to its original approach, or mix the two, or whatever. Eventually it was easier just to quit fighting it and let it do things the way it wanted.

> What I've seen is that after the initial dopamine rush of being able to do things that would have taken much longer manually, a few iterations of this kind of interaction has slowly led to a disillusionment of the whole project, as AI keeps pushing it in a direction I didn't want.

> I think this is especially true if you're trying to experiment with new approaches to things. LLMs are, by definition, biased by what was in their training data. You can shock them out of it momentarily, whish is awesome for a few rounds, but over time the gravitational pull of what's already in their latent space becomes inescapable. (I picture it as working like a giant Sierpinski triangle).

> I want to say the end result is very akin to doom scrolling. Doom tabbing? It's like, yeah I could be more creative with just a tad more effort, but the AI is already running and the bar to seeing what the AI will do next is so low, so....

[1] https://news.ycombinator.com/item?id=46784594

One of the most annoying things is senior leadership thinking that these tools give them the ability to just go do things, then the actual engineers are stuck reviewing the massive amount of slop.

Output from AGIs used by experienced engineers tends to be vastly different quality than output from these leaders who are too disconnected from the slaughtering.

It's currently unclear what the long-term effects of offloading coding to AI will be for developers, and posts like this are not meaningful, as they have zero data to work with. I suppose they feel good to write if you're the type who thinks that a theory with zero data is as good as one with data.

- semi retired IT Admin with 10+ years field experience in the toughest markets

- Nobody is learning how to use it correctly because everyone is lacking creativity and everyone is complaining instead of trying things

- I have built - scripts, 3D model pipelines for blender addons, websites, .net c# desktop apps, cloud security scripts, windows 11 tools that would take years to build in hours or days, linux tools, cli tools, assembly experiments just because, embedded projects for no reason

- I built a complete OEM Tier 1 Dyno safety tool for auto that would technically be 10 million in development - the barrier to entry for this world is almost entirely impossible but I built the damn thing anyways

- I built a quantum tool I have no idea if its actually useful or not but I still built it https://github.com/zerocool26/Quantum-Observability-Contract...

- I test all the models to see how advanced they can get with 3D modeling and its gotten much much better especially with gemini 3

- I am now focused on working on multi platform video games built with rust, go, node and am actively searching for investors I have a working demo of a multi platform game with 6 months development on it

So...what does it cost you?

One of my early experiences with AI coding was actually away from the keyboard. I was looking for my keys and just wanted to ask my agent. Very valid use case, but sent dependency chills down my spine. I've been more conscious since and following Sherry Turkle

https://www.npr.org/2025/07/18/g-s1177-78041/what-to-do-when...

[deleted]

this article claims humans will review code. there will be a date where the ai code review will meet your SOC compliance policies for change management

It’s worth pointing out that as of February 2026 the costs here are still pretty speculative. We’ve got some small sample studies on developers, and we have some anecdotal transmission of certain skills falling away. But frankly, if these anecdotes and limited data were attached to some statement about Rust, for example, no one would give them any credence whatsoever.

What we’re working with -—unfortunately—-are vibes. It really seems as though AI coding will have this effect on people. Morally, it seems like it ought to have this effect on people. We should not be allowed to be at ease without some sort of cost. And if we can luridly suggest that you don’t pay with money all the better.

This allows for the piece to perform its function, even when it doesn’t fully commit to it. A work in the genre can say all sorts of nuanced things about agentic coding, while still keeping the core premise that those who resist or position themselves strategically will be the winners.

That’s possible! It’s entirely possible that we will see some skill atrophy that is broken down by AI usage AND materially impacts outcomes that matter. We for sure do not know whether or not that is the case. I suspect it is because we don’t ask what these predictions cost you, which is nothing.

If we look at the starting point for most people on this stuff, it’s basically last fall. The author points this out, but the necessary conclusion one was draw from this is that we don’t have enough information to tell what the cost will be. It may like moving to programming languages from assembly or moving to assembly from bespoke instructions—-fundamentally very little was lost in those transitions, despite there being a lot of carping about it. It could be like the introduction of the tablet in American schools, where what we lose is nearly everything. We really do not know. It might be prudent to be cautious in this situation, but we ought to respect the fact that this caution might be born out of an old paradigm.

So basically the same cognitive debt that accrues to engineers the moment they become managers.

Shocking that devs are forgetting that writing and testing code gives us a conceptual map of what the code does...

Almost like someone never ever learned what the core of code development is....

This is why I use zettelkatsen as my own coding AI....long term results are far better than using AI to pretend to code.

> Every developer I know uses AI for coding now.

Currently I am working on a code base that is rapidly evolving for customer fit and is hoped to be around for a while. Going over recent decisions about what abstractions to focus on and what to cut it really seems like LLM tools would have been a waste for any aspect of this work. This is not a situation where some existing process needs to be encoded, and every choice about naming and structure ends up making a big difference as changes trigger refactors.

And this piece focuses on the early adopter point of view. Sure there were problems at first, but then whatsit tool thing version whatever came out and now roses are growing out of the rocks. For a large fraction of what is done with coding that makes sense, but there should always be attention to the rough parts and the gap that forms where capabilities fall off. Even a small amount of modesty can go a long way, but the conversation keeps starting off from every developer, all development, the change is now or else, and I for one am not buying that, especially not with actual money which is what these services will be charging soon in order to pay their trillion dollar debt service.

It remains unclear to me why my ability to read and review code (the majority of my job for years now) will atrophy if I continue doing it while writing even less code than I was before.

If my ability to write code somehow atrophies because I stop doing it, does that matter if I continue with the architecture and strategy around coding?

The act of writing code by hand seems to be on a trajectory of irrelevance, so as long as I maintain my ability to reason about code (both by continuing to read it and instruct tools to write it), what’s the issue?

Edit to add: the vast majority of the code I’ve worked on in my career was not written by me. A significant portion of it was not written by someone still employed by my employer. I think that’s true for a lot of us, and we all made it work. And we made it work without modern coding assistants helping out. I think we’ll be fine.