7 ms·

What AI coding costs you

• sarkarsh 7mo ago
  [dead]
• tomwojcik 7mo ago
  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
  • mold_aid 7mo ago
    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?
    • mold_aid 7mo ago
      didn't even take 24 hours: https://news.ycombinator.com/item?id=47190947 https://news.ycombinator.com/item?id=47190947
  • MattRix 7mo ago
    I’d encourage you to read this post: https://factory.strongdm.ai https://factory.strongdm.ai 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.
    • FridgeSeal 7mo ago
      I have this conversation (or a variation threof) with some friends: I suspect that the vast majority of “mainstream commercial software development” is flat out just cooked. We won’t be writing code, nor debugging it. It’ll will just be people throwing more LLM compute at everything. Open source, hobbyist and personal projects will probably remain the last bastions of “human in the loop” and human-written code, and I suspect these circles will retract into smaller, tighter circles.
    • lubujackson 7mo ago
      My question is always: what are you building? You need to tell the AI what to build. What if it does it in a way that isn't what you want, or makes the buttom blue instead of red, or any number of other decisions? AI can write the code, but not tell you what code you want it to write. In other words, how long are your specs? Either the LLM decides "whatever" or you have massive amounts of documentation to coordinate. We still need to decide what to build, and some of the how. That is not automate-able, yet everyone seems to gloss over that bit.
      • MattRix 7mo ago
        Yes, the LLM writes the specs. In fact that LLM writes everything, and then the humans only flag anything they want changed, other than that it’s completely automated. Imagine you were working with a very talented software shop. You might tell them your preferences sometimes and some things you want changed, but otherwise they mostly just build the right things the right way. And unlike a real software shop, the LLM system can implement changes incredibly fast.
  • radleta 7mo ago
    Thanks, I like it! Thanks for taking time putting it together.
  • throwaway346434 7mo ago
    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) On working memory and trainability: https://www.nature.com/articles/nrn.2016.43 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-hand-is-better-for-memory-and-learning/ 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 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 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.
  • gengstrand 7mo ago
    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/ 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.
    • skyberrys 7mo ago
      Hey your write up is good too. I thought the specific application to software architecture apart from software engineering is a valuable contribution, because software architecture is where if the AI tool goes wrong the repercussions have a longer term effect.
  • pindab0ter 7mo ago
    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. It is hard to understate how difficult that is.
• verdverm 7mo ago
  One of my early experiences with AI coding was actually away from the keyboard. I was looking for my keys and just wanted to ask my agent. Very valid use case, but sent dependency chills down my spine. I've been more conscious since and following Sherry Turkle https://www.npr.org/2025/07/18/g-s1177-78041/what-to-do-when-ai-says-i-love-you-we-talked-to-an-artificial-intimacy-expert https://www.npr.org/2025/07/18/g-s1177-78041/what-to-do-when...
• ryanmcl 7mo ago
  [dead]
  • dawnerd 7mo ago
    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.
    • tao_oat 7mo ago
      And they love to do this in spite of writing "NO FALLBACKS" etc. in your AGENTS.md.
    • vergessenmir 7mo ago
      If you don't have the experience you can't provide it with stylistic guidance, or idiomatic patterns or provide examples to direct it. This leads to the idea that LLMs with existing languages can't really learn new idiomatic patterns. For new engineers I think new paradigms will emerge that invalidate the need to know the current set of design patterns and idioms. Look at the resurgence of unit tests or the new interests in verification systems.
    • re-thc 7mo ago
      > They generate code that’ll get a positive result at any cost, even if it’s horrible in efficient. If only efficiency is the only problem with that. Sometimes an error state should an error. This is the equivalent of eating all exceptions and pretending all is fine. It just means nothing works.
    • apitman 7mo ago
      > it’ll teach you bad habits So will most programmers
    • lgas 7mo ago
      It seems to do this kind of stuff more when you're not looking too. Like I'll be approving edits all day without any problem then the second I set it to auto it gets a lint error about dead code and adds a pragma to allow the dead code instead of removing it, etc.
• heartbreak 7mo ago
  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.
  • encomiast 7mo ago
    "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.
    • dangus 7mo ago
      Per your last paragraph, I also think we are in an awkward middle period where developers are embarrassed to admit how much code is vibes with very little review before they submit. The embarrassment is understanding. It feels wrong, because in many ways it is wrong. The only way I’ve had this feel any better is by using it on a non-critical internal tool. I can confidently say “I didn’t write any of this code because it’s a quality of life tool that only lives on developer manners and is not required at any point in our workflow.” I also agree with the article that, unless computer science departments maintain some pretty strict discipline, this idea of a seniority collapse could be very real. Will we need those senior engineers if AI keeps getting better? I don’t know. Maybe one day the AI systems are going to just be trusted to be able to untangle complex architectural problems. If it wasn’t for leaded gasoline, rudimentary cancer treatment, and a good section of my modern video game catalog. I might be wishing I was born earlier.
• dventimi 7mo ago
  So...what does it cost you?
  • encomiast 7mo ago
    Goethe answered this in Faust. The answer is always: your soul.
    • dventimi 7mo ago
      Can you be more precise?
      • Towaway69 7mo ago
        If you sell your soul to the devil, don’t expect to make a profit.
        • dventimi 7mo ago
          I'll take that as a "no".
      • encomiast 7mo ago
        uh...okay. The legend of Faust is the classic work where a person sells his soul to the devil for power/knowledge/pleasure. Goethe has Faust make a wager with the Mephistopheles: show me the good life (pleasure, power, knowledge, whatever) it will never be enough to make me stop striving, to make me want to linger. If you can do that my soul is yours. To me it reads a _lot_ like our contract with AI.
        • dventimi 7mo ago
          I don't have a contract with AI.
          • encomiast 7mo ago
            It was meant metaphorically. It gives you something, but it asks for something in return.
• deleted 7mo ago
  [deleted]
• docheinestages 7mo ago
  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.
  • grayhatter 7mo ago
    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.
    • docheinestages 7mo ago
      I'm not disagreeing with your point. A good understanding of the domain and relevant systems is quite crucial. My point is that you don't always need to inspect the code at such low-level detail, provided there are tests or other ways to prove that the code behaves in the way that you describe.
      • grayhatter 7mo ago
        > My point is that you don't always need to inspect the code at such low-level detail, provided there are tests or other ways to prove that the code behaves in the way that you describe. This is true *only* in isolation. The pain of going through said depth of detail, is what builds the intuition for the whole system. Once and twice may not be noticeable, but a new habit, and that new habit's corresponding extreme downtime because no one understands the quirks anymore... Despite a few engineers who stake their life on the testing system, tests can't catch all issues. And it's extremely difficult to stop an oil tanker.
    • fibonachos 7mo ago
• foolfoolz 7mo ago
  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
• noduerme 7mo ago
  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.
  • marginalia_nu 7mo ago
    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.
    • wiseowise 7mo ago
      This. And there would be huge investments in productivity and reducing bureaucracy.
    • dehrmann 7mo ago
      I've worked places that actively acknowledged they were paying a productivity tax for people to have unexpected encounters, and they'd recover the losses at a higher level.
  • jnovek 7mo ago
    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.
    • deleted 7mo ago
      [deleted]
    • 9dev 7mo ago
      FWIW, I'm responsible for our engineering team, and I'm the one starting to put some gentle pressure on the developers right now. Velocity used to be one of the bigger issues we had: Features used to be in development over weeks, while customers, product management, and engineers iterated on the feature, until it was finally deemed stable enough and shipped. With AI, we can shorten that cycle considerably, and get stuff out of the door in days or even hours instead. Doing so requires adapting your processes accordingly, give up some control over the details, take good care of tests, and do proper code reviews. Given all that, I just cannot ignore AI as a development tool. There is no good justification I can give the rest of the company for why we would not incorporate AI tools into our workflows, and this also means I cannot leave it up to individual developers on whether they want to use AI or not. This pains me a lot: On the one hand, it feels irresponsible to the junior developers and their education to let them outsource thinking; on the other hand, we're not a charity fund but a company that needs to make money. Also, many of us (me included) got into this career for the joy of creating. Nobody anticipated this could stop being part of the deal, but here were are.
• josefrichter 7mo ago
  "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!
  • smeej 7mo ago
    I don't think we're even seeing 90% now, and we certainly weren't in June or September of last year, which was when it was predicted.
    • josefrichter 7mo ago
      We can argue about percentage points and months here and there, but we're very quickly coming to 100% and people aren't even afraid to admit it publicly anymore. The prophecy was definitely on point.
      • slopinthebag 7mo ago
        I would wager we aren't even at 50%.
• the__alchemist 7mo ago
  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.
• Towaway69 7mo ago
  > 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.
• PeterWhittaker 7mo ago
  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".)
  • grayhatter 7mo ago
    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 for a display update, sounds like memory ordering
    • PeterWhittaker 7mo ago
      Re determinism: that's what we'd like to believe, but it's true only if we redefine input to include overall build and execution context, and the latter is generally unreproducible. Over the last few years I've seen plenty of subtle bugs, some caused by UB, some caused by interactions with the overall execution environment, that resulted in mostly correct but sometimes wild and haphazard results, all for the same "input". Once these bugs were fixed, things became deterministic, but to say that all software is deterministic is to assert some level of programming, build, and operational consistency that is often achievable with great effort. Re gcc hacks: nope. No gcc'isms anywhere in the code, all warnings enabled, no warnings produced, just one case where a field is not updated in one very specific set of circumstances. Thanks for the suggestion, but that was one of the first things we thought of. There is a slight chance that it is actually a clang/llvm call stack depth bug, but the effort to reproduce that outweighs the impact of the bug, what with one thing and another not relevant here. UB -> occasional non-determinism.
• deleted 7mo ago
  [deleted]
• apples_oranges 7mo ago
  It’s like walking vs taking bus or car. It’s nice to walk sometimes..
  • kaffekaka 7mo ago
    Actually a pretty good metaphor.
  • falkensmaize 7mo ago
    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.
• irusensei 7mo ago
  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.
• adampunk 7mo ago
  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.
• VikRubenfeld 7mo ago
  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.
  • kaffekaka 7mo ago
    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.
  • cracell 7mo ago
    This is actually a big advantage of using AI. 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.
• googamooga 7mo ago
  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.
  • siva7 7mo ago
    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.
    • googamooga 7mo ago
      Yes, fully agree with you. Although, I read some stories that in early 60s a lot of people who used to program in opcodes (because there were no higher-level languages, even assemblers were quite new and "untested") were also struggling to accept new reality that was coming with Algol, Fortran, amd Cobol. But given that the absolute number of programmers in the world at that time was quite low nobody paid attention to their fears and pains. To me, personally, this shift is really enabling and refreshing. I usually have lot's of ideas but did not neither time nor capacity to play with them. Some of them were just impossible to do as a team of one. Now everything is possible! :)
  • ip26 7mo ago
    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)
• bwestergard 7mo ago
  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.
• fredgrott 7mo ago
  Shocking that devs are forgetting that writing and testing code gives us a conceptual map of what the code does... Almost like someone never ever learned what the core of code development is.... This is why I use zettelkatsen as my own coding AI....long term results are far better than using AI to pretend to code.
• crazypyro 7mo ago
  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.
• Yokohiii 7mo ago
  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.
• alvabuddha 7mo ago
  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.
  • cracell 7mo ago
    > micro-agression against readers
    • slopinthebag 7mo ago
      The commentator was trying to be polite. Passing off LLM generated work as your own is a dick move to the reader. It's plagiarism.
• monkeydust 7mo ago
  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.
  • linkjuice4all 7mo ago
    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?
    • monkeydust 7mo ago
      Prioritisation due to cost of engineering forces you to think hard about what to build (and thus not to build). If that calculation has now radically changed, which it has, then that presents a whole new risk that has not been thought about extensivley yet but I suspect will be. It might be that customers can develop the thing they want (that say not other customer does) themselves through well defined interfaces but then who supports and maintains that code?
• xantronix 7mo ago
  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.
  • teeray 7mo ago
    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.
    • layer8 7mo ago
      Not to mention that tests are at least as critical to get right as the code that is being tested.
      • wreath 7mo ago
        And not to mention that most tests available to AI training is trash, so no wonder AI-generated tests are not only worthless but costly in terms of false sense of reliability.
    • __mharrison__ 7mo ago
      This is why I teach TDD when I'm teaching agent use to my clients.
  • bwestergard 7mo ago
    Well said. 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?
• dddgghhbbfblk 7mo ago
  >Every developer I know uses AI for coding now. And for blogging too, it seems.
  • happycube 7mo ago
    Yeah this feels at least partially Claude-written to me too.
• ravila4 7mo ago
  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.
  • throwaway346434 7mo ago
    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.
• m0llusk 7mo ago
  > Every developer I know uses AI for coding now. Currently I am working on a code base that is rapidly evolving for customer fit and is hoped to be around for a while. Going over recent decisions about what abstractions to focus on and what to cut it really seems like LLM tools would have been a waste for any aspect of this work. This is not a situation where some existing process needs to be encoded, and every choice about naming and structure ends up making a big difference as changes trigger refactors. And this piece focuses on the early adopter point of view. Sure there were problems at first, but then whatsit tool thing version whatever came out and now roses are growing out of the rocks. For a large fraction of what is done with coding that makes sense, but there should always be attention to the rough parts and the gap that forms where capabilities fall off. Even a small amount of modesty can go a long way, but the conversation keeps starting off from every developer, all development, the change is now or else, and I for one am not buying that, especially not with actual money which is what these services will be charging soon in order to pay their trillion dollar debt service.
• mkoubaa 7mo ago
  So basically the same cognitive debt that accrues to engineers the moment they become managers.
• tinmandespot 7mo ago
  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.
• tombot 7mo ago
  > 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.
• rafaelmn 7mo ago
  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.
  • bwestergard 7mo ago
    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.
  • throwaway346434 7mo ago
    It is very true in a physical sense. "Use it" results in neural pathways being formed. What happens when you dont use them? https://www.sciencedirect.com/science/article/abs/pii/S0160289620300623#:~:text=Disuse%20atrophy%2C%20or%20the%20%E2%80%9Cuse,considered%20deprived%20of%20work%2Drelated https://www.sciencedirect.com/science/article/abs/pii/S01602...
    • rafaelmn 7mo ago
      I meant in the physical sense of muscles/physical adaptations. I haven't read/written C++ in 10 years - it would take me a month to get back up to speed. If you never written C++ it would take you at least 6 months/year to get to the same level (depending on what we're comparing here). Likewise for physical exercise - it took me a year to hit 100kg squat when I started getting into shape 10 years ago. I haven't been very physically active for years but I'd hit 100x5 in a month of starting gym again.
• sabretooth1405 7mo ago
  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”
  • smeej 7mo ago
    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.
• YesBox 7mo ago
  There's another great comment by daxfohl that I saved. The "complacency" at scale worries me [1] Copied to save you a click: > I worry about the "brain atrophy" part, as I've felt this too. And not just atrophy, but even moreso I think it's evolving into "complacency". Like there have been multiple times now where I wanted the code to look a certain way, but it kept pulling back to the way it wanted to do things. Like if I had stated certain design goals recently it would adhere to them, but after a few iterations it would forget again and go back to its original approach, or mix the two, or whatever. Eventually it was easier just to quit fighting it and let it do things the way it wanted. > What I've seen is that after the initial dopamine rush of being able to do things that would have taken much longer manually, a few iterations of this kind of interaction has slowly led to a disillusionment of the whole project, as AI keeps pushing it in a direction I didn't want. > I think this is especially true if you're trying to experiment with new approaches to things. LLMs are, by definition, biased by what was in their training data. You can shock them out of it momentarily, whish is awesome for a few rounds, but over time the gravitational pull of what's already in their latent space becomes inescapable. (I picture it as working like a giant Sierpinski triangle). > I want to say the end result is very akin to doom scrolling. Doom tabbing? It's like, yeah I could be more creative with just a tad more effort, but the AI is already running and the bar to seeing what the AI will do next is so low, so.... [1] https://news.ycombinator.com/item?id=46784594 https://news.ycombinator.com/item?id=46784594
  • deleted 7mo ago
    [deleted]
• butterlettuce 7mo ago
  [deleted]
• rbliss 7mo ago
  A reasoned argument I agree with. The challenge is that the competitive and economic pressures make this moot. A person, entering the field via AI driven development, will have none of the qualms about skill, seniority, understanding the codebase, or craftsmanship. Those arguments are handwringing by the previous generation of engineers. Their focus is solely on the outcome and value produced from the input prompt. That aligns closer to how businesses see their codebase: something they have to prompt their engineers to produce in order to generate business value. Similarly, new AI driven companies focused on delivering value at speed and lower costs will have none of the baggage of the legacy code companies with engineers stuck debating these questions. These new gen companies will be focused on delivering value, doing so at quicker speeds and lower costs, raising the level of competition for existing incumbents. Will existing businesses be willing to spend money to purchase services from these new gen companies of AI developed products? Seems like it. There are real problems with these AI developed codebases. They tend to collect baggage and start to feel like a house of cards. A big open question is whether AI models will continue to improve in order to patch all the vibe-holes being generated. Seems like they will improve.
• mwcampbell 7mo ago
  > Boilerplate and scaffolding Have we really reached the limit of how much we can reliably automate these things via good old metaprogramming and/or generator scripts, without resorting to using unreliable and expensive statistical models via imprecise natural language? > Refusing to use AI out of principle is as irrational as adopting it out of hype. I'm not sure about this. For some people, holding consistently to a principle may be as satisfying, or even necessary, as the dopamine hit of creation mentioned in the article.
  • bradbeattie 7mo ago
    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.
• andrewingram 7mo ago
  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.
• Vexs 7mo ago
  I recently accepted-ish a position at a very ai-forward company. Manual programming was somewhat discouraged entirely. I've used AI tools in the past for maths I didn't understand or errors I couldn't make sense of, and wrote the bulk myself, but now we have as mentioned, opus/sonnet 4.5- which work great. As part of this, I had to integrate two new apis- nornally, when I write an API wrapper I end up learning a lot about how the API feels, what leads to what and how it smells, etc. This time? I just asked Claude to read it's docs, then gave suggestions about how I wanted it to be laid out. As a result? I have no idea how these apis feel, their models, etc. If I want to interact with them, I ask Claude how I do a thing with the library it made. Mind you, the library is good. I looked over everything, it's fairly thin and it's exactly how I would write it, as I suggested it do. But I have no deep understanding, much less an understanding of how it got integrated in. Like, normally when I integrate something in I learn a bit about the codebase I'm integrating it into. Do that enough times, and I understand the codebase at depth, how things plug in. This time? Nada. It's.... Deeply uncomfortable, to know so little but still be able to do so much. It doesn't matter if I get it to explain it, that's just information that washes off when I move onto the next thing. The reflexive memory isn't built. All of which is to say, I agree with the article.
• chiengineer 7mo ago
  [dead]
  • happycube 7mo ago
    Agreed - if you're only writing things with Claude Code that would exist anyway (largely day job things) you're missing out. Having an AI-slop version of X for your own gratification is usually better than having no version at all.
• onion2k 7mo ago
  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.)
  • empath75 7mo ago
    Replace this with “writing assembly”
• kledru 7mo ago
  > "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.
• mentos 7mo ago
  >> That deep, focused, creative problem-solving where hours disappear and you emerge with something you built and understand. Yea but for how long? Go back and read any code you wrote a year ago and realize it could have been AI that wrote it.
• phendrenad2 7mo ago
  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.
• deleted 7mo ago
  [deleted]
• deleted 7mo ago
  [deleted]
• geraneum 7mo ago
  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.
• apitman 7mo ago
  That was a nice collection of brief history, links to research and other articles, and original thoughts.
• skyberrys 7mo ago
  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.
• jmux 7mo ago
  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
• amdivia 7mo ago
  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
  • eterps 7mo ago
    You could give https://github.com/jurriaan/aico https://github.com/jurriaan/aico a try.
    • amdivia 7mo ago
      Seems very interesting thanks for sharing! (even tho it still has a review process, but I feel it's heading in the right direction)
• bluefirebrand 7mo ago
  > 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.
• erelong 7mo ago
  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
• timrogers 7mo ago
  > 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.
• agentultra 7mo ago
  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.
• october8140 7mo ago
  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.
• zezaeoh 7mo ago
  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?
• fud101 7mo ago
  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.
• ms9598 7mo ago
  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.
• 28304283409234 7mo ago
  We sysadmins have been seeing this for decades with docker, k8s and cloud adoption. None of the engineers I work with are able to debug a simple networking issue or compile a trivial piece of c code. Otoh: didn't Socrates say the same about writing? It rots the brain?