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.
That’s why I laugh when people are like “oh, AI writes all the tests, it’s so much easier.” If your code is hard to test, you need to change the abstraction or the interface. Tests are the first reuse of your code, so if it’s a pain to use in tests, it’s going to be terrible to use in general.
Completely resonate with this. There don't seem to be many of us, at least in my online bubble, but you're not alone.
I believe and hope eventually we'll come around to valuing people who have put in the work - not just to understand and review output but to make choices themselves and keep their knowledge and judgement sharp - when we fully realize the cost of not doing so.
Wanted to chime in that, at my job, hand-writing code has been massively helpful when debugging it. My mental model of what can go wrong is much easier to form if I wrote the code. A LLM will not always be able to solve these incidents, no matter how many logs you throw at it.
Yes! I love to code. I love the entire process end-to-end. I love doing all the things people say they prefer to hand off to LLMs. Makes me sad to see all the people allowing corporations to slowly rob them of all the little joys this field has to offer.
I've found that I reach for Copilot most often when working on frontend javascript code. Will the incentive to improve the frontend libraries, browser standards, etc vanish now that LLMs let us avoid some of this pain?
Especially true for junior-mid engineers. The brain stores and comprehends what you tend to repeat.
If I don't solve math problems I won't understand how to solve them, no matter how many times I see videos of people solving similar problems. This is what LLM usage early on will ultimately lead to, and anyone who will claim "oh, by the time I'll be senior the LLM's will be much better than me" only proves my point.
I continue to do all of those things but have Claude do the typing for me, if that makes any sense. I'm directing it on almost a line by line basis, I just am not that interested in doing syntax pushups anymore.
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
Fun read. Audience can see Xeno's Arrow emerging on your "we're on the way to AGI!" timeline, a nice visual representation of "the trajectory is real, but the timeline keeps slipping."
But I'm gonna say I've always seen "[retail software] is just a tool" as an odd statement. I've heard it a lot over the last 20 years. "Just" a tool. Why always phrased like that? How can we be overthinking the role of a tool while you're in the middle of a multi-page essay about how it causes cognitive decline?
Nobody frets about the effect of a screwdriver on some IT rando's ability to do other computer stuff if on occasion they're screwing something into a rack. Seems odd to be so consistent about privileging the concept of a "tool" when you're saying that tool is on its way to thought.
>I’m addicted to prompting, I get high from it
yikes, but I did appreciate this honesty. Though, again: "this hash pipe is just a tool" did not appear after this statement
Also - isn't addiction behavioral, as opposed to strictly neurological? Maybe you should do a follow-up on the behavioral effects of a situation like "There’s no spark in you anymore." If you found a new identity that wasn't "I'm a prompt addict," what would it be?
This post resonates with me. I recognize everything you said except for the metrics part, since my employer luckily doesn't do that.
It's addictive. You're fast, efficient, you feel like you're in control. All while you're slowly losing grip.
I love how nuanced your takes are. The biggest challenge of this new programming paradigm is not to see how you can use it to its fullest extent. It is to find out what a sustainable pace is, both sort and long term.
Thanks for writing this blog. Others are also starting to notice these impacts and writing about them. I believe that it is important for more voices to be heard.
What resonated most for me was the "Finding Your Threshold" section. Your "Developers need the dopamine hit of creation." is memorable. I have also blogged about this phenomenon at https://www.exploravention.com/blogs/soft_arch_agentic_ai/ but I frame it more as how leaders can help the organization arrive at a healthy and sustainable balance between writing and reviewing code.
Basically had the same urge to write about this problem, prompted by the exact same comments around mental fatigue this week. Only got to the research stage.
Here's some of the literature I dug up when looking at what is the potential risk to cognition when you don't enjoy what you are doing.
Working memory is "gated"; you selectively process information relevant to a goal - or why you need to turn the radio off to reverse a car.
(Numerous papers take it as a given, can't find a specific one developing the exact model of gating)
I would argue that typing is better than just reading, and programming requires some extra elements - as you cut and paste to rearrange, run tests, iterate, spatially navigate to where various areas of your code is; so is likely closer to the findings around handwriting than the study. But I don't have specific studies on that.
"Participants performed a delayed-estimation orientation working memory (WM) task with reward cues indicating reward levels at the beginning of trials. The results revealed that motivational incentives significantly improved WM performance and increased pupillary dilation during maintenance. These findings provide evidence for the modulation of WM maintenance by reward through enhanced top-down cognitive control processes."
https://www.jneurosci.org/content/39/43/8549
> "During the task, the prospect of reward varied from trial to trial. Participants made faster, more accurate judgements on high-reward trials. Critically, high reward boosted neural coding of the active task rule, and the extent of this increase was associated with improvements in task performance"
You can also infer from their experiments that low reward = less care exercised.
I feel like a lot of these papers aren't really surprising, but they do measure something that many people have probably felt is true but can't prove.
While these papers don't talk about AI or decline in skills specifically, it's reasonable to say you don't get many of the benefits when it is low reward/passive task execution; where you are leaving review comments that are just reprompting a machine - you know it's not a person, so it feels even lower value to engage than a standard code review might.
I think overall, the rule of thumb around when to use AI should be closely linked to how painful / low reward a task is likely to be. Debugging something with a 10 minute build/test loop and a mystery problem that is not easy to control? AI party.
Writing a complex but fun set of business rules? Run it on your wetwear while it is still giving you a sugar hit. An "easy" bug you have stuffed up fixing three times in a row? Push through a bit of discomfort and frustration; but fall back to tooling when you have invested reasonable efforts and are starting to feel slightly fatigued.
It hit the front page here a few weeks ago, but I don’t think most people took it seriously and got hung up on the $1000/day in tokens part.
I am convinced that approach is the future of nearly all software development. It’s basically about how if you’re willing to spend enough tokens, these current models can already complete any software task. With the right framework in place, you don’t need to think about the code at all, only the results.
I really don’t like that the industry is heading this way, but the more I consider that approach, the more I’m convinced it is inevitable.
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.
If programmer speed and efficiency was truly such a significant competitive factor, we wouldn't be packing them like sardines them in noisy and stuffy open floor plan offices.
Do you have management pressure to use these tools? I don’t have any data but me and virtually every software engineer I talk to regularly is feeling or has felt pressure to use these tools.
Am I alone in thinking atrophy might not happen? I use a keyboard all day but it doesn't mean I can't write by hand anymore. Predictive text didn't make me forget how to spell. If i buy coffee it doesn't mean I forget how to make it
yup. no effort - no bliss. and for rare bouts of wanting to shepherd cats I just got meself some actual cats. At least they don't pretend to be engineers.
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.
I think this is a false comparison, and I believe cognitive science will show this to be true over time.
"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."
But the cognitive capacities you developed reasoning about opcodes almost certainly made it easier for you to learn FORTRAN and its successors.
LSI-11 opcodes, FORTRAN 83, C++, the lambda calculus, etc are all formal languages that we can reason about logically. It's also the case that we can implement machines (hardware or virtual) that can in practice produce the results that match our logical deductions. This is generally what people mean when they say these languages are "deterministic".
It seems obvious to me that it is more cognitively demanding to reason about formal languages like these, to prove to oneself that a given change in the code will produces the outcomes you intend, than it is to prompt for changes in the code and review it.
One significant difference is that all programming languages, whether machine code or python, have always been a precise language for describing the desired computation or algorithm. Working with an AI agent means specifying what you want the program to do in English, which is not precise. Unless you write English pseudocode.
(Yes, I know the compiler does wild stuff behind the curtain, but unless you're using -Ofast, the assembly is black-box-equivalent to a naive compilation)
The difference between now and then is a grand skill shift (from logic to vibe) and also fear of being replaced by this technology which was never the case before at this scale. You and me, we don't have this fear but many colleagues fear this new tech and also those colleagues who seem to get along with 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 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.
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.
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.
The biggest problem is it’ll teach you bad habits. For example, Claude and gpt love to use fallbacks. They generate code that’ll get a positive result at any cost, even if it’s horrible in efficient. If you don’t have past knowledge you might just think that’s how it is.
Now before someone says that junior devs make the same mistakes, yes, to some extent.
Models don't learn. They retrain them periodically, but junior engineers learn much faster and constantly improve. If you stop learning, you will only be as good as the model.
I've been coding (software engineering, I guess) for close to 15 years. The models skill set is a comfortable L1 (intern), pushing L2 (junior). They are getting better, but at a snail pace compared to a human learning the same thing.
get the system to build a clean architecture and explain it to you. it will help it to build a better system. a huge part of working with these models for engineering is getting them to create reports. for themselves and of course for us to read and understand. the bottleneck is actually our verification capacity.
Claude Code has a “learning mode” that makes it explain what it’s doing and leave “TODO(human)” placeholders in the code where you have to do part of it.
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.
I spend a lot of time side by side with other devs watching them code and providing guidance. A trend I'm starting to sense is that developer velocity is just as much hindered by unfamiliarity with their tools as much as it is wrestling with the core problem they really want to solve.
When to use your mouse, when to use your keyboard, how to locate a file you want to look at in your terminal or IDE, how to find commands you executed last week, etc. It's all lacking. When devs struggle with these fundamentals, I suspect the desire to bypass all this with a singular "just ask the LLM" interface increases.
So when orgs focus on a "devs should use LLMs more to accelerate", I really wish the focus was more "find ways to accelerate", which could more reliably mean "get more proficient with your tools".
I think there's a lot of good that can be gained from formalizing conventions with templating engines (another tool worth learning), rather than relying on stochastic template generation.
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.
I doubt it's possible to draw a concrete line between in domain, and out of domain. Would you mind trying with a specific example? Because so much of engineering is understanding the interactions between systems. While I cant enumerate the exact asm codes, I do need to understand how the compiler is going to rewrite my function if I want to understand if a cast is safe, or if this function call order needs to be rewritten, or if I'm need a mutex to protect this from a torn read.
I think Mitchell Hashimoto as a pretty sane take here, where he uses LLM's to offload stuff he doesn't care about / want to think about so he can spend more time and brain power on the stuff that really matters. I tend to agree.
I was recently analyzing a TypeScript module in our new project to learn how it works, and was thinking, "I wouldn't have done it like this” and “the styling is not for me". Then the realization slapped me in my face: this code came from me!
This article also slapped me, and has crystallized my jumbled thoughts on the topic. I'm deep into my career as a productive software engineer, yet I'm concerned there is a visible vanishing point of my value. My retirement is also visible, but I'm more concerned about our trade and those of you who have many years ahead.
While adaptation is hard when moving a lightspeed, workflows must adapt, more time on imprinting the generated code into our heads with iterating on trialing, testing, editing, before PRs is prudent.
A larger problem is architectural drift and leak. Those feel like they could become extremely problematic. We’ll need to put more effort into steering agents so their output aligns with architectural goals. The steering will also need to be iteratively refined.
Great article! I’m concerned, but also rallying for us.
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.
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.
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.
The debugging gap in the Shen-Tamkin study is the part that worries me. AI tools are great at generating code from a clear spec. But the skill that atrophies is recognizing when code is subtly wrong — and that's the exact skill you need most when reviewing AI output.
What works for me: write the spec in a markdown file before handing it to the agent. Predict what it'll produce before reading the output. When it surprises you, figure out why before accepting. Keeps you engaged enough to actually build mental models.
The management pressure angle in this thread is real. If your org measures velocity in lines shipped, AI tools will optimize for that metric and comprehension dies quietly.
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
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.)
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.
The problem is this is the difference between one or two obscure skills fading away with disuse (normal); and potentially all ability to load programming information into your working memory being affected; as you didn't develop the neural pathways or knowledge of the codebase (not normal or desirable)
While it is a spectrum around when you choose to use AI, what seems increasingly common in my experience is some people trying to go "all in", feel frustration and burnout when they are relegated to babysitting an LLM; get angry that it has made a mistake, misinterpretation or simply left something obvious out; then thinking it's user error/they didn't prompt well enough/it is their fault. At the same time, they are increasingly cognitively blind to mistakes at a review stage, so they find out the hard way in production and enter into a cycle of hyper vigilance/distrust/justifiable paranoia.
In those cases, it's a recipe for skills loss and depression over the long term and a vicious cycle.
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
I often come back to a quote from Tony Hoare (paraphrased):
There are two ways to write software: either it obviously has no errors or there are no obvious errors in it.
LLMs tend to generate the latter. Because that’s what’s in the training data: all the code that was rushed to production with a promise it would be fixed later. And humans are notoriously bad at catching these kinds of errors.
It feels bad using tools like this because it turns you into a reverse centaur. You’re there because the tool cannot be held accountable. You’re the last mile delivery driver shipping the code. You didn’t participate in its construction and you take all the responsibility for it.
Only there are studies which demonstrate how small of an impact code review has on code quality. And that after reading a few hundred lines of code in an hour the effect disappears. Current AI processes aren’t equipped to handle this.
Whatever we’re doing it’s heading in the opposite direction of engineering.
> 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.
I’d argue it’s more like driving yourself vs passively being driven everywhere. Remember that scene at the end of E.T.? Where Elliott and his brother steal the van, but they don’t know how to get to their destination because “I don’t know streets mom always drives!”. LLMs are mom always driving - you might recognize some landmarks after a while, but you don’t know the names of the streets to get anywhere.
> Reviewing AI output all day without the dopamine of creation is not a sustainable job description.
I agree that reducing engineers’ careers to code review will lead to burnout (amongst other problems).
But I think the reason we’re headed in this direction is precisely because creating with AI /can/ deliver “the dopamine of creation”.
It doesn’t deliver that hit for everyone - but it does for the half of engineers who are more excited about building new things than the act of coding.
Teams build more and ship faster because it’s so much easier to do that with AI - and it’s fun - and that leads to increased review load.
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.
I think you could probably identify different "risks" and then just code in such a way as to mitigate them; I don't personally think there would have to be much of a risk of atrophy of skills if this is done.
I guess it reminds me of someone switching from a manual labor job to a desk job: you become at risk of physical issues from being more sedentary, but you can exercise after work or even some people have things like standing desks and such to keep active during the job
So there can be real risks but there should be ways to manage them
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.
Other comments have mentioned upstream delays in deciding what features to build now that teams can deliver faster - but you bring up another issue around downstream “understanding debt”. How can sales and marketing sell this stuff if they don’t even know what everything does? How does customer service support it? Sure you can just slop-together documentation, blogs, etc but what good are all these extra features if end-users don’t know or just don’t care about them?
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.
> "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 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”
I wonder whether there's a relevant analogy between human languages and computer languages.
I've read hundreds of books. It may be thousands if you count the multiple series I devoured as a bookish child. I think my understanding of my mother tongue is probably in the top decile of native speakers.
But I haven't ever written a book. I'm not sure I would want to write a book, though I'm reasonably sure it wouldn't be the linguistic skills that would keep me from finishing one if I did.
Not having written any books doesn't keep me from knowing whether a book I'm reading was written well or poorly. I can tell that from my extensive experience reading a variety of books of different quality.
Maybe that's what's coming for computer languages. Maybe people who like reading, interacting with, and understanding computer languages will become highly skilled readers, with the ability to recognize well-written and poorly-written code. Perhaps they'll be the ones guiding the models to improve the code generation, or finding the structural changes that would improve the code for companies making truly important projects.
Or maybe we're just going to end up with incredible amounts of poorly written drivel that works well enough for some niche audience and makes a few bucks for the person who spins it up, and most software won't ever matter on any sort of large scale, just like most books aren't ever read. Maybe there will be some pockets that really care about writing very well and producing excellent things, and they'll hire the people who love bringing that about, and the rest of the people currently developing software will have fun little hobby projects that only their friends and family ever bother to use.
This doesn't seem that different from what has happened with written human language to me.
I think what’s interesting is technical debt is contained in a project, but cognitive debt is contained in a person. I think we will see good developers pile up so much cognitive debt they will nuke their own careers.
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.
I don't think it is that simple. Innovation can be found on several levels, from the lowest next-token level up to the higher level of new ways of combining things. Surely LLMs can produce code that on the whole does something completely new, even if on a syntactical level it has all been seen before?
We only have a couple dozen letters, still it is possible to write new poetry.
Should we seek the dopamine reward of creativity in writing code?
Isn't delivering the value created through the developed results to users itself a creative act?
Will the ability to review code (which is important now) become important in the future?
Is it necessary to have a pipeline to nurture seniors?
Wouldn't it be more important to define clear requirements, verify that the resulting code operates properly within various guardrails, and clearly communicate the designed value, than to be able to review code?
> 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 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.
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.
With exercise and cognition alike, the concern is motivational. If you let yourself get out of shape, it can be very difficult to rebuild the habits required to get back into shape. You get drawn into a bad local maximum (e.g. prompting everything, driving everywhere) and find you don't have the energy to get out.
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.
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.
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....
"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!
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.
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".)
all code is deterministic for a given input. If you don't understand the behavior, it's because you don't understand the complete set of inputs into the system.
Assuming you're not tripping over some hardware defect, it sounds like you're using a gcc hack that llvm doesn't support
Until a majority of software engineers become unemployed, we won't collectively wake up and act which is what we should to this existential crisis unfolding. Action more than yet another plausible sounding article.
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
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
> Refusing to use AI out of principle is as irrational as adopting it out of hype.
My principles have nothing to do with whether or not AI is giving me extra productivity though. Even if AI made me 5000x more productive I still wouldn't want to use it out of principle. I think it is a deeply immoral technology that shouldn't exist
I also think that people who research and build AI are deeply immoral people who should be tried for crimes against humanity
Because I have no doubt in my mind that AI is leading us towards crimes against humanity. We are going to be culled the moment we are not useful anymore.
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.
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’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.
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.
"so as long as I maintain my ability to reason about code…what’s the issue?"
It seems like that is the open question. The article suggests that people don't maintain this ability:
"The AI group scored 17% lower on conceptual understanding, debugging, and code reading. The largest gap was in debugging, the exact skill you need to catch what AI gets wrong. One hour of passive AI-assisted work produced measurable skill erosion."
From my own (anecdotal) experience I am seeing a lot more cases of what I call developer bullshit where developers can't even talk about the work they are vibe-coding on in a coherent way. Management doesn't notice this since it's all techno-bable to them and sounds fancy, but other developers do.
> The act of writing code by hand seems to be on a trajectory of irrelevance
It does not. English (or any human language) is an awful language to write specifications in, because it is not as precise as code. Each time you "compile" your prompt into a program, LLMs spit up something a little bit different. How is it a good thing?
> 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?
The post mentions this. You need to write code yourself to keep your review skill (know what's good and what's bad) sharp. You think why if you want to learn something, you better get a paper, a pen and write notes, by hand, like in those ancient times? You would think we're in 2026, you can grab an ipad, watch some videos and become an expert? No. You need to have your hands dirty. By writing some damn code.
Even before AI, I’ve witnessed at Google plenty of L6 and L7 software engineers atrophy. They stop writing code, start reviewing code, until they find that their code reviews catch fewer issues than a junior engineer’s reviews. They have become accustomed to thinking only at a high-level, and when met with low-level details they can’t tell good from bad any more. Their coding skills, both reading and writing, have atrophied.
How do we maintain best practices when the compiler outputs a different result for the spec at any given time? How do we obtain reproducible builds? Do we pin to a specific version of our compiler (ie, snapshot of the model; is this possible anywhere except local currently?), and vigorously test changes after any updates in our "toolchain"? How do we have control over our "toolchain" (again, apart from local), especially when said "toolchain" can, for all its users simultaneously, fold to political pressure from state regimes? And, if the code generated by LLMs is the build artifact, why is it now okay to check the build artifact into source control?
There may come a day when we, as an industry, decide that simply doing it by hand is more expedient when it comes to resolving urgent production issues. We may not know the pain we are causing ourselves until well into the future when it has become too much to bear without a visit to the proverbial doctor.
xantronix|1 day ago
I remain because I remain hopeful the pendulum will swing the other way someday.
teeray|1 day ago
bendmorris|1 day ago
I believe and hope eventually we'll come around to valuing people who have put in the work - not just to understand and review output but to make choices themselves and keep their knowledge and judgement sharp - when we fully realize the cost of not doing so.
JTbane|1 day ago
iaaan|1 day ago
bwestergard|1 day ago
I've found that I reach for Copilot most often when working on frontend javascript code. Will the incentive to improve the frontend libraries, browser standards, etc vanish now that LLMs let us avoid some of this pain?
whatever1|15 hours ago
Did I ever feel joy from trying to figure out the api of an obscure plotting library? No. And thankfully I never have to do it again.
Thanemate|1 day ago
If I don't solve math problems I won't understand how to solve them, no matter how many times I see videos of people solving similar problems. This is what LLM usage early on will ultimately lead to, and anyone who will claim "oh, by the time I'll be senior the LLM's will be much better than me" only proves my point.
slekker|1 day ago
mold_aid|1 day ago
Yeah nicely said.
zzzeek|1 day ago
tomwojcik|1 day ago
mold_aid|1 day ago
But I'm gonna say I've always seen "[retail software] is just a tool" as an odd statement. I've heard it a lot over the last 20 years. "Just" a tool. Why always phrased like that? How can we be overthinking the role of a tool while you're in the middle of a multi-page essay about how it causes cognitive decline?
Nobody frets about the effect of a screwdriver on some IT rando's ability to do other computer stuff if on occasion they're screwing something into a rack. Seems odd to be so consistent about privileging the concept of a "tool" when you're saying that tool is on its way to thought.
>I’m addicted to prompting, I get high from it
yikes, but I did appreciate this honesty. Though, again: "this hash pipe is just a tool" did not appear after this statement
Also - isn't addiction behavioral, as opposed to strictly neurological? Maybe you should do a follow-up on the behavioral effects of a situation like "There’s no spark in you anymore." If you found a new identity that wasn't "I'm a prompt addict," what would it be?
pindab0ter|1 day ago
It's addictive. You're fast, efficient, you feel like you're in control. All while you're slowly losing grip.
I love how nuanced your takes are. The biggest challenge of this new programming paradigm is not to see how you can use it to its fullest extent. It is to find out what a sustainable pace is, both sort and long term.
It is hard to understate how difficult that is.
gengstrand|1 day ago
What resonated most for me was the "Finding Your Threshold" section. Your "Developers need the dopamine hit of creation." is memorable. I have also blogged about this phenomenon at https://www.exploravention.com/blogs/soft_arch_agentic_ai/ but I frame it more as how leaders can help the organization arrive at a healthy and sustainable balance between writing and reviewing code.
radleta|1 day ago
throwaway346434|1 day ago
Here's some of the literature I dug up when looking at what is the potential risk to cognition when you don't enjoy what you are doing.
Working memory is "gated"; you selectively process information relevant to a goal - or why you need to turn the radio off to reverse a car. (Numerous papers take it as a given, can't find a specific one developing the exact model of gating)
On working memory and trainability: https://www.nature.com/articles/nrn.2016.43 Working memory is (potentially) dopamine responsive, and expanded by use/training.
On building mental models, writing something down activates more of your brain than typing (cognitive offloading): https://www.scientificamerican.com/article/why-writing-by-ha...
I would argue that typing is better than just reading, and programming requires some extra elements - as you cut and paste to rearrange, run tests, iterate, spatially navigate to where various areas of your code is; so is likely closer to the findings around handwriting than the study. But I don't have specific studies on that.
On reward ($) as a proxy for enjoyment/flow state; and motivation; these two used similar basic designs to experiments https://www.nature.com/articles/s41598-025-09949-1
"Participants performed a delayed-estimation orientation working memory (WM) task with reward cues indicating reward levels at the beginning of trials. The results revealed that motivational incentives significantly improved WM performance and increased pupillary dilation during maintenance. These findings provide evidence for the modulation of WM maintenance by reward through enhanced top-down cognitive control processes."
https://www.jneurosci.org/content/39/43/8549 > "During the task, the prospect of reward varied from trial to trial. Participants made faster, more accurate judgements on high-reward trials. Critically, high reward boosted neural coding of the active task rule, and the extent of this increase was associated with improvements in task performance"
You can also infer from their experiments that low reward = less care exercised.
I feel like a lot of these papers aren't really surprising, but they do measure something that many people have probably felt is true but can't prove.
While these papers don't talk about AI or decline in skills specifically, it's reasonable to say you don't get many of the benefits when it is low reward/passive task execution; where you are leaving review comments that are just reprompting a machine - you know it's not a person, so it feels even lower value to engage than a standard code review might.
I think overall, the rule of thumb around when to use AI should be closely linked to how painful / low reward a task is likely to be. Debugging something with a 10 minute build/test loop and a mystery problem that is not easy to control? AI party. Writing a complex but fun set of business rules? Run it on your wetwear while it is still giving you a sugar hit. An "easy" bug you have stuffed up fixing three times in a row? Push through a bit of discomfort and frustration; but fall back to tooling when you have invested reasonable efforts and are starting to feel slightly fatigued.
MattRix|1 day ago
It hit the front page here a few weeks ago, but I don’t think most people took it seriously and got hung up on the $1000/day in tokens part.
I am convinced that approach is the future of nearly all software development. It’s basically about how if you’re willing to spend enough tokens, these current models can already complete any software task. With the right framework in place, you don’t need to think about the code at all, only the results.
I really don’t like that the industry is heading this way, but the more I consider that approach, the more I’m convinced it is inevitable.
noduerme|1 day ago
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.
marginalia_nu|1 day ago
jnovek|1 day ago
josefrichter|1 day ago
bdbdbdb|23 hours ago
stavros|21 hours ago
lstodd|1 day ago
adampunk|1 day ago
googamooga|1 day ago
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.
bwestergard|1 day ago
"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."
But the cognitive capacities you developed reasoning about opcodes almost certainly made it easier for you to learn FORTRAN and its successors.
LSI-11 opcodes, FORTRAN 83, C++, the lambda calculus, etc are all formal languages that we can reason about logically. It's also the case that we can implement machines (hardware or virtual) that can in practice produce the results that match our logical deductions. This is generally what people mean when they say these languages are "deterministic".
It seems obvious to me that it is more cognitively demanding to reason about formal languages like these, to prove to oneself that a given change in the code will produces the outcomes you intend, than it is to prompt for changes in the code and review it.
ip26|1 day ago
(Yes, I know the compiler does wild stuff behind the curtain, but unless you're using -Ofast, the assembly is black-box-equivalent to a naive compilation)
siva7|1 day ago
matltc|1 hour ago
It's fleventy five
wrs|1 day ago
tinmandespot|1 day ago
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.
Vexs|1 day ago
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.
andrewingram|1 day ago
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.
ryanmcl|1 day ago
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.
dawnerd|1 day ago
Now before someone says that junior devs make the same mistakes, yes, to some extent.
levkk|1 day ago
I've been coding (software engineering, I guess) for close to 15 years. The models skill set is a comfortable L1 (intern), pushing L2 (junior). They are getting better, but at a snail pace compared to a human learning the same thing.
inciampati|1 day ago
wrs|1 day ago
mwcampbell|1 day ago
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.
bradbeattie|1 day ago
When to use your mouse, when to use your keyboard, how to locate a file you want to look at in your terminal or IDE, how to find commands you executed last week, etc. It's all lacking. When devs struggle with these fundamentals, I suspect the desire to bypass all this with a singular "just ask the LLM" interface increases.
So when orgs focus on a "devs should use LLMs more to accelerate", I really wish the focus was more "find ways to accelerate", which could more reliably mean "get more proficient with your tools".
I think there's a lot of good that can be gained from formalizing conventions with templating engines (another tool worth learning), rather than relying on stochastic template generation.
docheinestages|1 day ago
grayhatter|1 day ago
slopinthebag|1 day ago
ms9598|7 hours ago
This article also slapped me, and has crystallized my jumbled thoughts on the topic. I'm deep into my career as a productive software engineer, yet I'm concerned there is a visible vanishing point of my value. My retirement is also visible, but I'm more concerned about our trade and those of you who have many years ahead.
While adaptation is hard when moving a lightspeed, workflows must adapt, more time on imprinting the generated code into our heads with iterating on trialing, testing, editing, before PRs is prudent.
A larger problem is architectural drift and leak. Those feel like they could become extremely problematic. We’ll need to put more effort into steering agents so their output aligns with architectural goals. The steering will also need to be iteratively refined.
Great article! I’m concerned, but also rallying for us.
Yokohiii|1 day ago
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.
geraneum|1 day ago
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.
the__alchemist|1 day ago
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.
sarkarsh|9 hours ago
What works for me: write the spec in a markdown file before handing it to the agent. Predict what it'll produce before reading the output. When it surprises you, figure out why before accepting. Keeps you engaged enough to actually build mental models.
The management pressure angle in this thread is real. If your org measures velocity in lines shipped, AI tools will optimize for that metric and comprehension dies quietly.
jmux|1 day ago
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
onion2k|1 day ago
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.)
empath75|1 day ago
ravila4|1 day ago
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.
throwaway346434|1 day ago
While it is a spectrum around when you choose to use AI, what seems increasingly common in my experience is some people trying to go "all in", feel frustration and burnout when they are relegated to babysitting an LLM; get angry that it has made a mistake, misinterpretation or simply left something obvious out; then thinking it's user error/they didn't prompt well enough/it is their fault. At the same time, they are increasingly cognitively blind to mistakes at a review stage, so they find out the hard way in production and enter into a cycle of hyper vigilance/distrust/justifiable paranoia.
In those cases, it's a recipe for skills loss and depression over the long term and a vicious cycle.
amdivia|1 day ago
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
eterps|1 day ago
agentultra|1 day ago
There are two ways to write software: either it obviously has no errors or there are no obvious errors in it.
LLMs tend to generate the latter. Because that’s what’s in the training data: all the code that was rushed to production with a promise it would be fixed later. And humans are notoriously bad at catching these kinds of errors.
It feels bad using tools like this because it turns you into a reverse centaur. You’re there because the tool cannot be held accountable. You’re the last mile delivery driver shipping the code. You didn’t participate in its construction and you take all the responsibility for it.
Only there are studies which demonstrate how small of an impact code review has on code quality. And that after reading a few hundred lines of code in an hour the effect disappears. Current AI processes aren’t equipped to handle this.
Whatever we’re doing it’s heading in the opposite direction of engineering.
Towaway69|1 day ago
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.
apples_oranges|1 day ago
falkensmaize|19 hours ago
kaffekaka|1 day ago
timrogers|1 day ago
I agree that reducing engineers’ careers to code review will lead to burnout (amongst other problems).
But I think the reason we’re headed in this direction is precisely because creating with AI /can/ deliver “the dopamine of creation”.
It doesn’t deliver that hit for everyone - but it does for the half of engineers who are more excited about building new things than the act of coding.
Teams build more and ship faster because it’s so much easier to do that with AI - and it’s fun - and that leads to increased review load.
skyberrys|1 day ago
erelong|1 day ago
I guess it reminds me of someone switching from a manual labor job to a desk job: you become at risk of physical issues from being more sedentary, but you can exercise after work or even some people have things like standing desks and such to keep active during the job
So there can be real risks but there should be ways to manage them
monkeydust|1 day ago
linkjuice4all|1 day ago
bwestergard|1 day ago
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.
kledru|1 day ago
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.
dddgghhbbfblk|1 day ago
And for blogging too, it seems.
happycube|1 day ago
unknown|1 day ago
[deleted]
sabretooth1405|1 day ago
I don’t know how I will be able to build intuition for code I don’t write just “understand”
smeej|1 day ago
I've read hundreds of books. It may be thousands if you count the multiple series I devoured as a bookish child. I think my understanding of my mother tongue is probably in the top decile of native speakers.
But I haven't ever written a book. I'm not sure I would want to write a book, though I'm reasonably sure it wouldn't be the linguistic skills that would keep me from finishing one if I did.
Not having written any books doesn't keep me from knowing whether a book I'm reading was written well or poorly. I can tell that from my extensive experience reading a variety of books of different quality.
Maybe that's what's coming for computer languages. Maybe people who like reading, interacting with, and understanding computer languages will become highly skilled readers, with the ability to recognize well-written and poorly-written code. Perhaps they'll be the ones guiding the models to improve the code generation, or finding the structural changes that would improve the code for companies making truly important projects.
Or maybe we're just going to end up with incredible amounts of poorly written drivel that works well enough for some niche audience and makes a few bucks for the person who spins it up, and most software won't ever matter on any sort of large scale, just like most books aren't ever read. Maybe there will be some pockets that really care about writing very well and producing excellent things, and they'll hire the people who love bringing that about, and the rest of the people currently developing software will have fun little hobby projects that only their friends and family ever bother to use.
This doesn't seem that different from what has happened with written human language to me.
october8140|20 hours ago
VikRubenfeld|1 day ago
kaffekaka|1 day ago
We only have a couple dozen letters, still it is possible to write new poetry.
cracell|1 day ago
Using simple mature tech stacks following best practices makes your product much better.
Developers have a strong desire to reinvent the wheel and it wastes so much time.
Innovative should only be attempted in your product domain if you are trying to make a successful company.
zezaeoh|20 hours ago
Will the ability to review code (which is important now) become important in the future? Is it necessary to have a pipeline to nurture seniors?
Wouldn't it be more important to define clear requirements, verify that the resulting code operates properly within various guardrails, and clearly communicate the designed value, than to be able to review code?
tombot|1 day ago
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.
alvabuddha|1 day ago
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.
cracell|1 day ago
mentos|1 day ago
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.
rafaelmn|1 day ago
throwaway346434|1 day ago
https://www.sciencedirect.com/science/article/abs/pii/S01602...
bwestergard|1 day ago
rbliss|1 day ago
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.
irusensei|1 day ago
YesBox|1 day ago
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
unknown|1 day ago
[deleted]
josefrichter|1 day ago
smeej|1 day ago
apitman|1 day ago
crazypyro|1 day ago
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.
PeterWhittaker|1 day ago
> 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".)
grayhatter|1 day ago
Assuming you're not tripping over some hardware defect, it sounds like you're using a gcc hack that llvm doesn't support
for a display update, sounds like memory ordering
unknown|1 day ago
[deleted]
fud101|15 hours ago
dventimi|1 day ago
encomiast|1 day ago
verdverm|1 day ago
https://www.npr.org/2025/07/18/g-s1177-78041/what-to-do-when...
foolfoolz|1 day ago
bluefirebrand|1 day ago
My principles have nothing to do with whether or not AI is giving me extra productivity though. Even if AI made me 5000x more productive I still wouldn't want to use it out of principle. I think it is a deeply immoral technology that shouldn't exist
I also think that people who research and build AI are deeply immoral people who should be tried for crimes against humanity
Because I have no doubt in my mind that AI is leading us towards crimes against humanity. We are going to be culled the moment we are not useful anymore.
butterlettuce|1 day ago
phendrenad2|1 day ago
mkoubaa|1 day ago
unknown|1 day ago
[deleted]
unknown|1 day ago
[deleted]
fredgrott|1 day ago
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.
m0llusk|1 day ago
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.
chiengineer|1 day ago
[deleted]
happycube|1 day ago
Having an AI-slop version of X for your own gratification is usually better than having no version at all.
adampunk|1 day ago
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.
heartbreak|1 day ago
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.
encomiast|1 day ago
It seems like that is the open question. The article suggests that people don't maintain this ability:
"The AI group scored 17% lower on conceptual understanding, debugging, and code reading. The largest gap was in debugging, the exact skill you need to catch what AI gets wrong. One hour of passive AI-assisted work produced measurable skill erosion."
From my own (anecdotal) experience I am seeing a lot more cases of what I call developer bullshit where developers can't even talk about the work they are vibe-coding on in a coherent way. Management doesn't notice this since it's all techno-bable to them and sounds fancy, but other developers do.
orphea|1 day ago
kccqzy|1 day ago
xantronix|1 day ago
There may come a day when we, as an industry, decide that simply doing it by hand is more expedient when it comes to resolving urgent production issues. We may not know the pain we are causing ourselves until well into the future when it has become too much to bear without a visit to the proverbial doctor.