23 ms·

AI is removing the middle class of software engineering?

• hemc4 2mo ago
  > AI makes projects with weak engineering culture fail much faster. Love this quote. Already seeing so many codebases which became unmaintainable.
• whywhywhywhy 2mo ago
  >AI makes projects with weak engineering culture fail much faster. >There used to be a time when people sat down and talked about how they'd do something. Now they can just prompt an agent for a few hours and open a PR. >The most tragic aspect of this way of working is that, to the untrained eye, it works. >If you pull the branch and test it, you'll probably get something somewhat functional. So what do they do? They keep going. Again and again. Until the project reaches a point where no one knows how anything works. Isn't this the opposite of failing faster, it lets people who would have never made it past the first few hurdles and give up get deep in and then the false hope that they can then prompt their way out of whatever mess resulting in deeper and deeper spaghetti.
  • florianherrengt 2mo ago
    But now they can now move so fast that nobody has a realistic chance to stop them before the damage compounds. They get into a much deeper mess much faster.
    • barbazoo 2mo ago
      We always talk about damage, what's the damage here?
      • flatline 2mo ago
        You deploy an application that ostensibly has the desired capabilities but it fails at scale, or the architecture is not extensible to add new capabilities or fix bugs. Those are expensive mistakes and in safety-critical domains could be deadly. The thing is I've worked on plenty of code like this written by humans. AI just accelerates the process and puts this type of code within reach of more people. It could be seen as a step backwards in good software engineering practices we've painfully learned over the last two decades. I see it as a cycle repeating itself in a new iteration, with the hope that we'll end up with still better tools and processes in another few years. But I agree it can and will result in real harm in the meantime.
      • josephg 2mo ago
        A giant pile of unmaintainable, brittle code nobody understands. At some point, even LLMs struggle to make changes without introducing bugs.
      • greenavocado 2mo ago
        The next decade of software consulting will be defined by repairing the Big Ball of Mud https://www.laputan.org/mud/ https://www.laputan.org/mud/
      • jayd16 2mo ago
        Waste of time and therefore money is a big one.
      • Kinrany 2mo ago
        For example, doing a marketing push assuming that the app works, and then having it fail in trivial ways at release.
      • danparsonson 2mo ago
        Code that accidentally ships every 100th order out for free... exploits releasing customer PID and causing regulatory nightmares... self-driving cars that reboot at 70mph... The only limit is your imagination!
      • florianherrengt 2mo ago
        Corrupted or lost customer data, security vulnerabilities, incorrect financial transactions, regulatory breaches, production outages, irreversible migrations, important product change effectively impossible without a full rewrite. Every feature takes longer, incidents take longer to resolve. Engineers spend their time fighting the codebase instead of building things, burn out and quit. I could go on forever.
      • whywhywhywhy 2mo ago
        Time lost when the real developers have to pick up the pieces and the viber has just moved on to the next shiny thing.
  • whateveracct 2mo ago
    > Now they can just prompt an agent for a few hours and open a PR. Bruh..I haven't consistently sat at my computer for even a hour at a time to code for a decade..people spend that much time in Claude??
    • whateveracct 2mo ago
      from the downvotes, it seems that people do spend more time in Claude than I do meatcoding. "Efficiency gains" lol
• jqpabc123 2mo ago
  In the words of Admiral Ackbar, "It's a trap". Any apparent short term gain is really a prescription for long term pain. Ignore what AI fanboys say and instead look at what they do. https://northeasttimes.com/2026/08/07/oracle-bans-ai-code-from-java-s-backbone-while-spending-billions-on-ai/ https://northeasttimes.com/2026/08/07/oracle-bans-ai-code-fr...
  • packetlost 2mo ago
    Oracle banned AI code for copyright reasons, you cannot interpret that as a assessment of the practical output of the models.
    • SpicyLemonZest 2mo ago
      It strongly argues against a position that many people including myself have taken, that all code will soon be AI code and the only people still writing code by hand are those who haven’t gotten the memo. (I don’t mean to rule out the possibility that Oracle, despite their involvement in AI infrastructure, is just being dumb and the lawyers made them create a policy that’s not compatible with the modern practice of software development.)
    • stonefoot 2mo ago
      That's only one of the three reasons in the article: 1) Reviewer burden - LLMs can produce a deluge plausible but incorrect code which can overwhelm human reviewers. 2) Safety and Security - Many corporations depend on the JDK so stability is a high priority. 3) Copyright/IP about who owns submissions generated by AI is not settled in law. The article also goes on to compare the JDK teams policy to GraalVM, also in Oracle which is more similar to the Linux kernel policy, where AI submissions are allowed, but the human submitter is accountable to them, which is reasonable too. It's not unreasonable, in my opinion, for the JDK team to limit AI contributions based on their stated priorities, just like how other teams might not require those same restrictions.
    • ok123456 2mo ago
      Oracle banned AI code from a public project they maintain and backport/share with a commercial product because they're a very litigious company, anticipating future legal cases.
• mococa 2mo ago
  I saw close some companies getting completely lost with AI code
• tantalor 2mo ago
  > Fixing it would require such a colossal amount of work that it would be impossible to even start justifying it to anyone in management. Bad news: by delegating the thinking to somebody else (Claude) you have become the management.
  • iugtmkbdfil834 2mo ago
    Nooo. But seriously, that does appear to be the end result on most of my recent sessions. The time I spend is on correcting, adjusting.. dare I say managing the process as opposed to actively editing every aspect of it.
  • trey-jones 2mo ago
    This is exactly how I feel about my job now. I'm the new manager. But honestly claude is better than any team of developers I've ever had working under me. It does exactly what I ask it to, in 10 minutes instead of 3 weeks. And apparently we can't afford a development team now anyway... I'm not working at massive scale. I've not built any public-facing projects from scratch. But I have done years-worth of cleanup and improvement on projects that I'm very familiar with and have been in my backlog. It's not 100% success, but it's better than I could have done on my own, in the last few months anyway.
    • eatsyourtacos 2mo ago
      Exactly this for me too. I don't know how to feel about this overall honestly, I'm able to do so much more but now I barely get to write any code. It's weird.
      • rootusrootus 2mo ago
        > I don't know how to feel about this overall honestly I'm at the "this takes the scut work off my plate but damn if it doesn't also take the fun stuff off my plate too, and might put me out of job before I'm ready to retire in 8 years" point. Though I've done the corporate America thing long enough to appreciate that 8 years isn't really all that long, maybe there's hope.
• declan_roberts 2mo ago
  Between AI and competing against the world with H-1B, it's really never been harder to get an entry or mid-level software engineering job. Which means our pipeline to senior engineer is completely broken.
  • mikert89 2mo ago
    I think the field is basically over as a long term career unless you are truly exceptional. It will become very easy to build most software, and the upper end will be filled with the top people in the country/from abroad. Wages are certainly going down for most software roles
    • esafak 2mo ago
      Only if you run out of things to write. Is your back log ever empty?
      • skinfaxi 2mo ago
        No one said there won't be work to be done, just that fewer people will be doing it.
        • esafak 2mo ago
          If the work to be done is infinite, why would there necessarily be fewer people doing it?
          • pjmlp 2mo ago
            Because most companies aren't software driven, they sell physical products and software is a cost center. There is a budget and when it is gone, no contractors until next budget round.
            • andriy_koval 2mo ago
              it could mean they are not completely out of automation opportunities, and will lose to more innovative players if won't invest into software. The end state of these companies is grid of cheap robots controlled by software.
• mikert89 2mo ago
  AI gives more leverage to exceptional people, its an amplifier not an extender
  • onesandofgrain 2mo ago
    Maybe
  • happytoexplain 2mo ago
    Right, it's a multiplier only if we define bad engineers as negative numbers, and "bad" as "most".
    • iugtmkbdfil834 2mo ago
      I know what you mean, but the amplifier could genuinely work both ways ( magnify bad and good outcomes ).
  • api 2mo ago
    That is true of all tools. AI is a tool. A tool provides leverage. It does not make a bad craftsperson good.
    • mikert89 2mo ago
      right but we have never seen a tool like this
      • snk 2mo ago
        https://en.wikipedia.org/wiki/Timeline_of_historic_inventions https://en.wikipedia.org/wiki/Timeline_of_historic_invention...
    • dgellow 2mo ago
      I hate that framing because it glosses over what makes AI distinct from other technology. Pretty much anything can be used as a tool, that’s not an interesting aspect of AI. However standard tools do not take decisions on behalf of the user, they do not apply judgement. They come with assumptions and constraints that make some decisions more likely to be made. But the whole thing about LLMs is that they apply judgement and take decisions. When you use an LLM you delegate both aspects to it with very little overview or control. I don’t think it’s “just a tool”, it’s something that directly compete with the role of humans in a system, by design
• pelagicAustral 2mo ago
  I don't know what kind of company has got a large codebase and it's taking 20,000 loc pr's expecting that shit to be sustainable, but I work AI first and at the most PR's are touching 12 to 15 files, with the more radical ones sitting at 30. They are still human-reviewable. They are still the kind of change you can revert back to original without breaking all the rest... there are ways of doing this stuff, dear luddites.
  • mezyt 2mo ago
    I was wondering how anyone could reach the token limit of a 200$/month Claude subscription. I never did on a 20$ one, and I'm parallelizing Claude to the absolute limit of what I can reasonably keep in mind. And I do that day and night, on week-end too with open-source. Now I'm absolutely convinced that it's by doing crap architectures and design that require 200k token of context before adding a single checkbox. If you apply good design principle and course correct the AI in real time before it commits to really stupid way to fix things (i.e. you don't ask it or let it do things that would make zero sense if you had to do it yourself), then the vibe coding cost way less and is way faster and easier to reason about.
  • florianherrengt 2mo ago
    I’m hardly a Luddite and you’re basically making my point. You’re deliberately constraining the output so changes stay small, human-reviewable and reversible. That’s good engineering culture. It isn’t all or nothing. I use AI heavily but that doesn’t mean I have to pretend there aren’t serious problems with how it’s being used.
• aabdi 2mo ago
  > You were never expected to understand every service and every database. But at least someone did and would explain it to you. I agree with most of this except this. Think there’s some rose tinted glasses here or I’ve got bad luck over time. Life before ai was bad as well. There wasn’t any one to explain to you anything! You had to figure it out yourself. The people either already left or was busy with something else. No one wrote tests (to my standard). Most of the ops works was skipped. Docs were just not there. Nobody linted properly. Just bad mannnn
  • uncivilized 2mo ago
    It’s just the typical BS where a Hacker News wants to feel smarter than they are
  • Kuraj 2mo ago
    If there is any positive to be had from this, it's that we finally started documenting the codebases for AI as we should have always done it for other teammates.
  • estetlinus 2mo ago
    +1 the vpn is called dev-test-prod and some containers are stored in a dev subscription, but still used in production. Some intangible network error forces you to use the production cluster for testing (the bucket is at least called test). I feel this kind of setup is invariant everywhere I go to do engineering. Fable level intelligence has no effect!
• petcat 2mo ago
  I think it is less about junior/mid engineers, and more just about the kinds of work inexperienced/cheap developers are often doing: assembly line, JIRA-ticket-taker type development. This is especially impacting Indian tech workers in the US [0] since these are often the types of roles that InfoSys and other foreign tech consulting firms are staffing. The new $100,000 fee to sponsor an H1B visa has made it difficult to justify hiring foreign tech workers when most of the time they are just going to be using American LLMs to do their work anyway. [0] https://thefederal.com/category/news/h1b-visa-indian-tech-workers-return-india-us-jobs-245525 https://thefederal.com/category/news/h1b-visa-indian-tech-wo...
  • sameesh 2mo ago
    What's with people using the number "0" for their first reference? I have only ever seen that practice here at Hacker News.
    • ebb_earl_co 2mo ago
      Lots of (most?) programming languages are 0-indexed so it feels natural for software developers and our ilk.
      • SoftTalker 2mo ago
        Not really. 0-based indexing is different from counting and starting with 0 in a counting context is weird. Would you ever say a set has zero elements when it actually contains a single element?
        • ebb_earl_co 2mo ago
          It's a remarkable coincidence that I'm reading the book The Nothing that Is: A Natural History of Zero by Robert Kaplan, and this passage on page 96 seems precisely relevant to this situation: """A Roman idiosyncrasy about counting reinforced this avoidance. The 360 degrees of longitude, for example, were always measured from the vernal equinox, which lies in the zodiacal sign of Aries. This should be zero degrees, 0°. It was common, however, to call it instead 'the first degree', Aries 1°, as Pliny did around 60 AD, upsetting his calculations and those of many who followed him. It amounts to this: if you lay out four marks on the ground and step from the first to the last, have you taken three paces or four? Clearly three; yet four marks were involved. To get the right answer it helps to call the starting-line 'zero'; then the number at the mark you step on will correspond to the number of your steps. But the Romans counted so that three days after Sunday was Tuesday; the Italian for the fifteenth century is the quattrocento — and all of us still call the two steps in music from C to E a major third, taking the number from the three tones involved.""" I wouldn't say that the set that has one element, labeled 0, _has_ zero elements; it has one element with the label 0. Right?
• Syntaf 2mo ago
  > bad engineers were always a liability This part of the article hits home for me. With AI, "bad" engineers can now amplify their "bad" engineering x10 across the organization. The most egregious of these cases for me is often long tenured engineers who have lost interest in the craft, creating a dangerous combination of having enough merit to ship but not enough interest to make what they ship _good_. I am still a firm believer in garbage in -> garbage out, AI is only as good as the abstractions and contracts you put in place for it. I don't subscribe to the idea that AI generated code is fundamentally bad, just that people lack the right skills today to wrangle agents into writing good code. Earlier in the year I put together a talk for my company on what the future of architecture & design means for us in the career, I'm very proud of it and will share here in case folks have their own thoughts to share on the topic: https://youtu.be/SIZrt9Rt05Q?si=W57eirniWmoSFeBu https://youtu.be/SIZrt9Rt05Q?si=W57eirniWmoSFeBu
  • CuriouslyC 2mo ago
    Ironically, AI mitigates bad developers quite a bit. The architecture/design is coming from above bad devs (in a functional org), and AI tends to write less sloppy code than bad devs, and test/validate it more rigorously.
    • mohamedkoubaa 2mo ago
      Jury is still out here
    • whateveracct 2mo ago
      AI is very good at making the bad dev's PR look plausible and be green in CI. And thus, merged.
    • re-thc 2mo ago
      > AI tends to write less sloppy code than bad devs, and test/validate it more rigorously I've often had it test and benchmark against the wrong things = no test. It also writes over-engineered code. So yes sort, maybe.
    • stackskipton 2mo ago
• mjr00 2mo ago
  It's very true, you used to have to hire people you knew were not very good just to have warm bodies who could throw together widgets, minor bug fixes, etc. You still had to have a competent developer review what they did, which was annoying, but ultimately a time saver over doing it themselves. Now the competent developer can just run agents and do the same review process, except it's ~free (relative to human salaries, even outsourced). So we've got a bimodal distribution going on where the bottom X% of developers have become essentially worthless while the top Y% of developers are now more valuable than ever.
  • platevoltage 2mo ago
    Well now you have lousy developers generating 1000 line PRs for their lousy colleague to approve while neither of them understand the code.
  • johnnyanmac 2mo ago
    > it's ~free (relative to human salaries, even outsourced). Even ignoring the shift to token based costs, the opportunity costs of throwing everything onto your "competent developers" isn't free. They still need time to review and correct output on top of whatever else they were doing in their day to day. And they probably aren't getting a pay raise either, so how long until they use that bullet point to jump jobs?
    • mjr00 2mo ago
      > the opportunity costs of throwing everything onto your "competent developers" isn't free. They still need time to review and correct output on top of whatever else they were doing in their day to day. Maybe it wasn't clear in my comment, but this was already happening in many large organizations pre-AI: you had a small contingent of competent senior developers whose job was to review and correct outputs from junior and/or outsourced staff. From people I've spoken to in these types of situations, they're very happy with getting rid of their offshore teams and using AI instead.
      • johnnyanmac 2mo ago
• brap 2mo ago
  It baffles me that someone can just send a PR without knowing the gist of how it works and why it’s done this way. If you can’t answer this basic question then why tf do we even need you around?
  • unified101 2mo ago
    Most people are currently too polite to ask the last part out loud. I suspect it will start changing soon.
• xyst 2mo ago
  AI generated code is the new "lines of code" metric used by middle management.
  • cbg0 2mo ago
    Actually "AI spending" is the new "lines of code" metric.
    • b40d-48b2-979e 2mo ago
      Too real. I got DMed by management recently asking if I was anti-AI because I had the lowest spend on the team as the lead, y'know, the one that has to review all the slop my peers are generating.
      • platevoltage 2mo ago
        That is rough, and downright embarrassing. What is happening in this industry?
      • ethagnawl 2mo ago
        I'm sorry. These charades are such a complete waste of time, energy and money. They're some real 21st Century Office Space nonsense. I recently joked (only slightly) that it's currently possible to get yourself promoted at these orgs using tokens as a productivity proxy by spending your days having Claude OCR dictionary pages. The concerning corollary of that joke and this management strategy is: when do orgs start offloading reviews to Claude? They're already surveiling a large percentage of peoples' day-to-day and are in a position (or will claim to be) to make a judgement about how those tokens are being used.
  • a34729t 2mo ago
    Oooooh we just started doing this at my company. There is no target set yet, but management feels it's between 50% and 100%. But people will be evaluated on this!
• 1294876 2mo ago
  "There are also people who essentially make it harder for everyone else. And now anyone can produce more code in a day than they used to in a year." That is the "democratization" that AI shills speak of: https://xcancel.com/dhh/status/2087538364580835804#m https://xcancel.com/dhh/status/2087538364580835804#m Once a CEO with a snowboard-optimized brain gave you a board seat, there is no way back.
• scronkfinkle 2mo ago
  I think of it more as "the automation of the stackoverflow engineer". In enterprise software, there has always just been a non-negotiable large volume of code that was required to be written. This has traditionally been offloaded by having seniors do the hard thinking then distill it into a jira ticket which could be handed off to an engineer that'd actually write the code and punch every hiccup into google along the way. This hand off is no longer necessary as that same senior can just kick off an agent and have it handle the implementation for them. I've heard some refer to this as a "nature is healing" scenario for the industry where if you only signed up for a high paycheck and didn't care to think critically about any of the work you're doing then this will be painful because that previously manual process has been automated. The floor of what's necessary to be considered valuable has been raised.
  • throwayay4929 2mo ago
    ... And Django and React removed ("stole the jobs from under") the engineers handcrafting html and jQuery web pages/apps.
    • jameshart 2mo ago
      Django? Django is older than jQuery…
    • platevoltage 2mo ago
      If you stopped learning during JQuery's heyday, You deserved to have your job stolen. This is not the same as watching AI ruin software platforms.
  • sarchertech 2mo ago
    >This has traditionally been offloaded by having seniors do the hard thinking then distill it into a jira ticket which could be handed off to an engineer that'd actually write the code and punch every hiccup into google along the way. This is the theory, but I’ve never worked anywhere (and I’ve worked at a lot of places over 20 years) that actually did it like that in practice. What tends to happen is that the EMs and PMs look at who’s free and give that person the task. This means that sometimes you get a senior leading a simple project and sometimes you get a junior leading/designing a complex project (usually with help from a very minorly technical PM). Then the senior/staff/principal (often on a different “special” team) gets pulled in at the last minute to rescue the project. If your company is highly product driven, you’ll often find that the juniors end up leaving projects more often than not because they will tell the PM exactly what they want to hear.
• fl4regun 2mo ago
  Economics would have always created this downward pressure on demand for software engineers regardless, either companies would replace the number of engineers they need with AI, or with low paid offshored workers.
• hn_submit 2mo ago
  Look, stupid companies who use A.I. to generate their code will simply fail. Companies that use bright engineers to engineer their product and write code (and pay them accordingly) will thrive and thrash the competition. Darwinism in action. I don't believe A.I. will change much, but it will lead to winners and losers, that's certain. Lessons will be learned, A.I. will remain but play a minor role, just like IntelliSense and ReSharper. People need to understand that when things break management will hold you accountable, not the A.I. If you can't fix it you'll be out of a job. So you'd better make sure that you understand the generated code and clean it up before putting it in production because you'll be maintaining it.
• i_idiot 2mo ago
  So, blame the engineers now? Most likely they were forced by a manager to push more PRs faster else piped.
  • florianherrengt 2mo ago
    [dead]
  • johnnyanmac 2mo ago
    Management's job is to take credit for success and deflect to the individuals when failure happens. That's never changed.
• fithisux 2mo ago
  Very good article. But it does cover the case where someone makes it to the top if he/she is junior. Who experience is gained? Maybe I ask too much from a short article.
  • florianherrengt 2mo ago
    [flagged]
  • fithisux 2mo ago
    it does cover - it does not cover
• timedude 2mo ago
  This is really well written. I deal with the exact same issues almost daily. Senior engineers who want to guard quality are becoming a bottleneck.
  • florianherrengt 2mo ago
    If the people trying to understand the changes and guard quality are now considered the bottleneck, the answer isn’t that the reviewers need to move faster.
    • timedude 2mo ago
      I wasn't saying that either
      • florianherrengt 2mo ago
        Then I’m not sure what you mean by calling them a bottleneck. If the limiting factor is the rate at which experienced engineers can understand and validate changes, you have three options: generate less, find a genuinely better way to validate or accept lower quality.
• jdw64 2mo ago
  I'm not sure what skill really means, or what's considered bad anymore. AI coding ability and human coding ability are different, and different organizations need different skills. No skill is inherently bad—it just depends on what the organization needs. I understand that AI writes better code than people like me in many cases. But an industry should still provide opportunities for those people. And sometimes those people create things that are better than AI in certain areas. The problem is when even those opportunities are taken away.
  • florianherrengt 2mo ago
    The industry doesn’t really owe people opportunities. Even if you think it should, that’s not how companies are going to behave.
    • jdw64 2mo ago
      That is an incredibly short sighted view. By acting this way, the industry is essentially selling its future for short term gains. A systemic reduction in the number of people capable of maintaining systems directly correlates with an inevitable collapse in overall software quality. The perspectives of market advocates often stop at this short sighted level. In reality, their modeling is incredibly simplistic. I will not elaborate at length on their poor modeling here. The short sighted local optimization that only chases the margin of the next quarter is the exact enemy we must guard against the most. (Of course, given the nature of HN, this specific part of the comment will likely be attacked.) It is not a matter of companies not owing anything; rather, companies are actively committing self sabotage. Is it truly right to eat tomorrow's seed corn today? The essence of the software industry is not the 'generation' of code, but the 'maintenance' of it throughout its life cycle. Why is Linux continually maintained, and why is Windows continually maintained? The core of this industry is fundamentally tied to the entire life cycle of a product. You might be able to fix code with AI. However, under the current LLM structure, can it actually modify projects spanning hundreds of thousands or millions of lines? It cannot. The skill required to partition those architectures is still entirely left to humans. And the ability to define those boundaries is born strictly from experience. Labeling certain individuals as useless or inadequate inherently destroys the resilience and buffer of the collective as a whole. Why do humans embrace and care for the vulnerable when society has the capacity to do so? Why do we strive to preserve diversity? It is because, depending on the context, those very traits might prove to be more advantageous. Every human possesses distinct skills, and their unique temperament and proficiency simply manifest depending on the situation they face.
• maerF0x0 2mo ago
  > In the story above, everyone is failing: IMO The author fails to list the hypothetical person with 13 PRs to review is also failing. > * The engineer who refuses to change with the times IMO many of the old ways of software engineering were local maxima. We're still seeking how to hit a new maxima and the journey may take us through zones lower than the previous local maxima.
  • florianherrengt 2mo ago
    I use AI heavily, so this isn’t about refusing to change. You still have to understand the change yourself if you’re going to take responsibility for approving it. That work is fundamentally much slower than generating the code, even with the help of AI. We’ve made producing a large change extremely cheap and fast. We haven’t found an equivalent shortcut for building a correct mental model of what that change does, how it interacts with the rest of the system and whether the decisions behind it are actually sound. Maybe one day we'll find one. As of today, I don’t think we have.
  • jplusequalt 2mo ago
    > * The engineer who refuses to change with the times There is plenty of software in existence where being incorrect, even once, can spell disaster. Everything about the picture being painted in the article is anathema to keeping such systems safe and reliable.
• tvbusy 2mo ago
  One thing this post did not discuss is the enormous effort required to explain to the management why number PRs has increased and number of lines changes, which in their view, means explosion of productivity, yet one engineer is destroying the team's momentum.
  • florianherrengt 2mo ago
    I tried to touch on that with this part: > Fixing it would require such a colossal amount of work that it would be impossible to even start justifying it to anyone in management. > And what are you even thinking about? It would end up in the exact same state again in just a few months anyway. The management side of this probably deserves a whole post of its own. There’s only so far I can take each tangent before the original post becomes too long for anyone to finish.
• v-mdev 2mo ago
  Great idea to include a link to Hacker News on your blog!
• throwitaway222 2mo ago
  Probably a good thing, we need more people building major mega projects like the Line. Potentially we need AI to mass produce architecture and scale up and out city/county building departments to open the gates to massive buildings in the United States.
• oceanplexian 2mo ago
  > The engineer opening a 25,000-line PR should have stopped the agent long before it got there. So many A car is simply a faster horse arguments being made here. The “You must review every line of code” camp are going to be in for a seriously bad time when Claude/Grok/etc starts writing machine code, and they absolutely will and you will look like a crazy person the same way as those who said we can’t trust compilers back in the 1970s. Breaking up code into small reviewable pieces is obsolete advice from legacy software engineering. We will probably be reviewing prompts or functional simulations as a form of review. Which brings me to the point that a Senior engineer in 5 years will look absolutely nothing like a Senior engineer in 2019.
  • florianherrengt 2mo ago
    I do have a genuine question though: what value are you adding at that point? If you don’t understand the system, don’t know what the code is doing and you’re mostly prompting an LLM to make the decisions and implementation for you, what exactly is your contribution? The ability to operate the tool isn’t much of a moat if everyone else has access to the same tool. I don’t review assembly produced by a compiler because the compiler isn’t deciding what my system should do. It’s translating a program whose semantics were already specified. More importantly, that translation is deterministic. A compiler takes a human-specified program and translates it into another representation while preserving its semantics. If in five years I can give an agent a complete specification and reliably verify the resulting machine code against it, then sure, reviewing code may become obsolete and I’d happily stop doing it. Also, keeping changes small isn’t just about making individual lines readable. It limits blast radius, makes behaviour easier to reason about, isolates mistakes, makes changes easier to revert and so many other things. None of those properties suddenly become obsolete because code generation got faster.
    • shishy 2mo ago
      Do you think it's impossible for someone to have a 25K line PR / diff but not know what's going on in the system? I ask because I've pushed some of this to the limit in my own testing and when I get the right building blocks / primitives in place in the repo, I'm able to get plans written in a way where I don't just describe what I want but specifically mention outcomes, verifications, constraints, etc. that utlimately describe the shape of my system and my intent. My plan is my understanding of my system and the changes I'm making, and the execution of that plan (e.g. with subagents), verified against my spec, is the code itself. With the correct building blocks, I've found that frontier models can write code in fairly predictable ways that lets me maintain my understanding and confidence in pretty large PRs. I think perhaps the quoted part of your post seems to imply it's not possible / isn't phrased with that nuance?
• rayiner 2mo ago
  Technology has been doing this for decades. I think a lot of our "K shaped economy" discourse is about the bifurcation of the upper middle class creating downwardly mobile educated young people. Nobody in my wife's immediate family finished college. She and all of her cousins are quite indisputably better off than their parents. My father in law drove a forklift at a soup factory. My sister in law is studying to be a nurse. It's a big step up. But the "white collar" middle class has become very winner-take-all. To use an example from my field, if your dad was a partner at a regional law firm, that path probably isn't open to you. Technology enabled consolidation and scaling, so you don't need lawyers in every city in the U.S. to be able to handle legal work there. Lawyers at national firms serving Wall Street clients are making more money than ever, but the drop below that has become pretty precipitous. The same has happened to small businesses all over the country competing with Amazon, etc. It's had a huge impact on the petit bourgeoisie. Of course, this is economically efficient. Nobody is going to give up Amazon same-day-delivery so that some local small business owner's kids can live better than the median person.
  • abnercoimbre 2mo ago
    > It's had a huge impact on the petit bourgeoisie. I always heard it as "petty" bourgeoisie and was a bit confused. Now I get it.
  • matheusmoreira 2mo ago
    Will it ever stop, though? I mean, why even try if social mobility has been destroyed? If we're the permanent underclass now, then there's no point in struggling against any of this.
    • tuesdaynight 2mo ago
      The class consciousness from middle class lately has been funny to me. We always had poor people that were "permanent underclass" and middle class didn't care. They were not afraid of revolution or whatever we are afraid now. If the bad scenario happens and 99% of the people becomes irrelevant to the economy, everybody will live their life's worried about basic necessities and smart hardworking people will be richer because your background or where you live or grew up doesn't matter. Life is not fair. We should accept that AI companies and billionaires deserve to be aristocrats. They worked hard to create these conditions. In the end, it will trickle-down (this one I partly agree, irony aside)
• user00005 2mo ago
  All of this is my fault. I decided to start learning programming about 6 years ago as a possible new career path. The universe was not going to have that so AI was created.
  • platevoltage 2mo ago
    I came on the market right as the Covid hiring boom ended and started to fall apart. Fun times.
  • gnarlouse 2mo ago
    It's YOUR fault! I knew it had to be one of us. Now I know. At least you were honest about it.
• bookofjoe 2mo ago
  It wasn't that long ago that many were demanding writing code be a required subject in elementary school.
  • florianherrengt 2mo ago
    The fact that a machine can do something better than humans doesn’t automatically make learning it pointless. We still teach arithmetic and algebra despite computers being vastly better at calculation. We teach spelling, grammar and essay writing. We even teach history and geography while everyone permanently has a device in their pocket that can look up almost any fact in seconds. How else would you be developing the mental models required to understand, question and verify anything?
  • rglover 2mo ago
    It still should be. Any educator worth their salt should be able to connect the dots on where all of this leads. I always joke with my wife and invoke a line from this [1] Art Bell episode "the disasters that are coming..." People really don't seem to consider that our civilization is remarkably fragile and dependent on humans. Any given system can just fail at a moment's notice and you need people around who know how not to panic and what to do. We seem to be adamant at disproving this reality for some weird reason (money, duh), but life isn't going to be fun when a large portion of the population needs a chat bot to do any form of work. And it's worth asking: what population will be left if we submit all of our faculties to LLMs? My guess is one that's either limited in size or practically inert. An outright idiocracy doesn't have to happen, but we sure as hell seem to be speed-running our way there. It's actually worth watching Idiocracy and Wall-E and just contemplating "do I really want to live in this world?" Because, at least right now, we're charting course directly toward that. [1] https://www.youtube.com/watch?v=gkPHMEvp-Tk https://www.youtube.com/watch?v=gkPHMEvp-Tk
    • anothereng 2mo ago
      you're right, some people should always be able to work without access to AI or the internet. I guess these people are essential services
• ryandvm 2mo ago
  Lord, this hits close to home. It doesn't seem to be happening everywhere, but if you are unfortunate enough to work someplace with a "LinkedIn thought leader" high up on the engineering food chain, there's a really high likelihood that your organization is currently in the throes of an "everyone must be using AI for everything" fever dream. And boy let me tell you, it is every bit as disastrous as the OP claims. Engineering managers are asking Claude to write up entire initiatives, then they hand off these nebulous AI slop manifestos to the teams where the requirements folks are having Claude shit out tons of superficially plausible Jira tickets. It finally lands on some poor engineer's plate and since these tickets are the technical equivalent of Finnegans Wake, they just end up asking Claude to read all this shit on `ultracode` and draft up a pull request. Which is then peer-reviewed by somebody using Claude. I wish I were exaggerating.
• dupflo 2mo ago
  At the same time, it also brings very low level "vibecoder" to the pool
  • florianherrengt 2mo ago
    I wrote about this before. I don't think the vibecoders will have a job for a long time. At best, it will be minimum wage. See "AI Won't Take Your Job, Someone Using AI Will" > There's no lucrative middle ground where 'AI whispering' is a high-value skill. https://blog.florianherrengt.com/vibe-coder-career-path.html https://blog.florianherrengt.com/vibe-coder-career-path.html
    • dupflo 2mo ago
      2026 is starting to slow time there emergency and 2027 will clean. Unfortunately they still contribute to overwhelm socials media with there content. Nice first name btw
    • bibimsz 2mo ago
      in 2 years there wont be many non-vibe-coders left employed
• danielovichdk 2mo ago
  "You can't afford bad engineers anymore" You never could.
  • florianherrengt 2mo ago
    Agreed. But it’s the difference between crashing at 30 km/h (19 mph) and crashing at 200 km/h (124 mph). AI massively increases the speed and scale at which bad engineers can do damage while fixing it is still slow, difficult work.
• parkersweb 2mo ago
  I have a theory that Claude regresses to complexity. It’s trained to mimic existing patterns - so the smallest grain of over-engineering or spaghetti-code is like a mind-virus, gradually infecting all future output and self-amplifying until all is spaghetti.
• zackmorris 2mo ago
  Wait till we realize that nobody is buying the software we vibe code anyway. We've seen this game before, with the Dot Bomb and 9/11. A lot of you have 6 figure jobs that will simply be gone next year after the election, never to return. That winter lasted about 5 years until 2007 when the iPhone and social media sites like Facebook went mainstream. This winter won't end. Or more accurately, it is the end. Maybe we should stop debating whether we're in a crisis and start looking at the 5-10 year endgame of the Singularity. We're entering the eventuality that many of us have predicted since the arrival of the internet 30+ years ago, that prices will get lower but nobody will have any money to buy anything anyway. The feeling that we're doing something wrong with our lives will continue to intensify. We'll try so hard, and get so far, but in the end, it doesn't even matter. I don't know about the rest of you, but I'm turning my attention away from trying to play the job game with AI. I'm looking instead at how we can provide time/money/resources to the middle class after capitalism can no longer provide them. A conservative friend of mine just read the Communist Manifesto by Karl Marx, which I didn't see coming, especially since he beat me to it. In the neurodivergent spirit of not being able to do anything alone, what if we all read it? https://oll.libertyfund.org/pages/marx-manifesto https://oll.libertyfund.org/pages/marx-manifesto https://www.marxists.org/archive/marx/works/download/pdf/Manifesto.pdf https://www.marxists.org/archive/marx/works/download/pdf/Man... I'm predicting that it stops just short of what full automation can provide. Loosely the evolution of economics goes: hunter-gatherer -> agrarian- > feudalist -> capitalist -> socialist -> communist. And now solarpunk (or something). The working class is looking forward to the next chapter, but the capitalist class is looking backward to neofeudalism. Those two directions can't coexist, so what does the future hold? Well, it's always darkest before dawn: "It's easier to imagine the end of the world than the end of capitalism." - Mark Fisher. https://www.youtube.com/watch?v=aCgkLICTskQ https://www.youtube.com/watch?v=aCgkLICTskQ Mark Fisher: The Slow Cancellation of the Future https://www.scribd.com/document/835022535/Mark-Fisher-The-Slow-Cancellation-Of-The-Future https://www.scribd.com/document/835022535/Mark-Fisher-The-Sl... (transcript) https://goodscienceproject.org/articles/the-slow-cancellation-of-innovation-a-critical-look-at-modern-funding/ https://goodscienceproject.org/articles/the-slow-cancellatio... https://mediationsjournal.org/articles/end-of-world https://mediationsjournal.org/articles/end-of-world If the endgame of capitalism is that it inevitably eats itself, then the game now isn't how to get more money and do nothing with it, but instead how to start doing something with no money. I should add that even if I'm exploring anti-capitalist futures, that doesn't make me socialist. I don't like the 6 hour daily work requirement of many socialist societies. I think we can do better than that and get closer to 0, so that we can shrug off wage slavery and finally get real work done.
• adamtaylor_13 2mo ago
  It's not clear to me what "the middle class" is supposed to be here. All engineers exist on some spectrum between "good" and "bad" and it's pointless to try to identify the exact markings, but we all know good engineers and bad engineers. So AI isn't really doing anything but giving sharper tools to both groups. So, as it was before, we simply need to set expectations and remove those who cannot adapt and meet expectations... You know, the way it's always been. So why is AI the problem here?
• devdude1337 2mo ago
  People should realize that programming is not a liability. Programming per se is the actual creation of detailed knowledge by writing. You get a task, how does it interact with all other invariants? What are the implications on data flow, processing and user workflows? You can rarely answer those questions beforehand, you step on them during programming as the formal language forces you to take them into account sooner or later. If you outsource this knowledge-building you’re losing the steering ability when stuff hits the fan. You lose the ability to navigate the code properly in order to identify bug or violations of invariants. LLM optimize locally, that’s their nature. Invariants are often implicitly scattered around the whole code base. Explaining them to the LLM is much more tedious than just to write the code in the first place. At least for me as I have much better expression-ability in Code than in natural language when it comes to describing any form of computation.
• waffletower 2mo ago
  While there are bad engineers, I imagine that teams that have evolved alongside AI and have maintained their size and consistency without adjustment may have structural issues. I would argue that team size counts ought to be smaller now than before Claude. Unfortunately this idea could feed an AI-induced layoff trend, but it could instead lead to product diversification instead.
• game_the0ry 2mo ago
  Writing code was never the job. Creating value was the job -- coding was just how to implement that goal.
  • Kinrany 2mo ago
    "Creating value", "making money", etc. are meaningless
    • bibimsz 2mo ago
      to many programmers, yeah
  • mattbettinson 2mo ago
    I shudder to think of anyone in the industry this would be mind-opening to
• eshack94 2mo ago
  This blog post illustrates the importance of NEVER outsourcing your critical thinking or outsourcing decision-making to an LLM. And to never take shortcuts with learning. Learning is hard, but learning things properly allows you to understand what is happening and allows you to ask the right questions about whether the changes an agent wants to make are the changes that will best serve the goals of the project (without creating an unwieldy level of tech debt in the future). Personally speaking (and I'd love to hear others' takes on this): when using an LLM for work-related and development tasks, I never use the "full-auto" mode, and I never manually approve of something that I don't understand. When I don't understand something an agent wants to do, I go on a side-quest to learn more about said thing and to educate myself first. This takes extra time, but I feel that it's the right thing to do, so I can at least approve/deny/redirect from a more informed position, rather than flying blind and hoping for the best. In addition to what the author discusses, I think skill-atrophy, stagnation due to complacency (i.e.: "why grow and learn if an agent can do it" mindset), and cognitive laziness are additional risks that come with overrelying on LLMs. Humans were meant to think. LLMs are a tool.
  • bluefirebrand 2mo ago
    > In addition to what the author discusses, I think skill-atrophy, stagnation due to complacency (i.e.: "why grow and learn if an agent can do it" mindset), and cognitive laziness are additional risks that come with overrelying on LLMs. Humans were meant to think. LLMs are a tool. I know it's a cliche but the old IBM adage holds very true today Machines should work, people should think Maybe that's part of the problem I have with LLMs writing code. It would be nice if they just did the work, but there's a lot of underlying thinking and decision making with software work that is being offloaded any time you have the LLM do it It seems like those decisions are being handwaved off as "not important" nowadays. Just let the LLM make those choices! But that is not sitting right with me for whatever reason. Something I should think about I guess
    • win311fwg 2mo ago
      The decisions are important, but the understanding is that you define them as constraints. Which is what a segment of the software community, the upper class if you will, has always believed you should do, even before LLMs were a thing. The LLM simply becomes a constraint solver: machines do the work, people do the thinking. This is the challenge of the middle class developer. They aren't accustomed to working with constraint thinking and they're past the junior stage where one is expected to still be shaping their thinking so they are struggling to find a fit.
• maxnevermind 2mo ago
  > - "Why are we doing this here?" > They send you a link. It's a Claude conversation. LLMs spared my neck of the woods for now but is this really how PR review looks like these days for an average SWE or its just an example of a Junior in a team?
• j45 2mo ago
  Ai isn't removing the middle class of software engineering. Software engineering is evolving, and the middle class (and beginner) is going to have to grow instead of being able to leverage the same skills for longer and longer. It's so true from some of the other posts that you can outsource your thinking, but you should never outsource your learning and understanding.
• theflyinghorse 2mo ago
  LLMs are an automated Indian dev-shop. That’s all. The code is poorly thought out, poorly implemented and doesn’t take performance into account. But the code works and you got it for cheap. That’s my mental model and I’m happy with it
  • omosubi 2mo ago
    If this is your mental model you will be disappointed in short order
• jplusequalt 2mo ago
  This blog conflates productivity with expertise. Are LLMs rewarding experienced developers with tons of productivity gains? Yes. Are LLMs actively degrading their expertise of understanding code? Also yes. This article has made the implicit assumption that the top quartile of engineers are immune from skill decline. They're not. If you're an engineer who increasingly outsources the planning, writing, and analysis of code to an LLM, you're losing your ability to plan, write, and analyze code. All of this is to say--senior engineers who have fully adopted AI tools are blowing smoke up their asses to dodge the reality of their own obsolescence. The senior engineers can talk about productivity all day, but they're only marginally closer to understanding a complex system that was written by LLMs than the "middle class" of engineers are. You reading this--yes you--get over yourself. Your skills are depreciating too.
  • florianherrengt 2mo ago
    [dead]
    • Alephinitesimal 2mo ago
      [flagged]
    • jplusequalt 2mo ago
      >What matters is whether you understand the change being made. If you don’t, then you’re not adding much value, because the LLM can do that part better and faster than you anyway. My point is that your ability to understand what a change is doing is tied to your ability to write and analyze code in the first place. If you no longer engage with either of those (also your ability to review requires you still understand how to write effective code), then AI will be removing you too.
• deadbabe 2mo ago
  A pattern I have noticed is you get way better results if you just have one skilled senior engineer coding everything with AI vs a lot of people. Having large teams in the age of AI is pointless. It slows things down and spreads accountability too thin. When you have one good engineer doing many things, a lot of stuff lives in their head and they know what to look for in their own PRs. Also, people tend to like their own AI slop, but not others. So overall you will have at least an engineer who is satisfied with the codebase vs a lot of people who either have some gripe about something someone else did, or just don’t care at all. That means you have to put way more trust in a single individual, but if it’s the right individual you propel the organization further ahead than a team of mediocre engineers or senior engineers limited in what they can accomplish.
• GrayHerring 2mo ago
  More like AI is exposing bad engineers faster than it would've been possible earlier. Previously they would simply outsource all their thinking to someone else, now they see massive progress with AI and delude themselves into wishful competence.
• TiccyRobby 2mo ago
  The premise does not make any sense, it is a technical culture problem which you need to enforce. If you let it go wild, yes it will go wilder than ever but this is relatively trivial problem.
  • johnnyanmac 2mo ago
    Problem is that many large companies all collectively decided that yes, we want it to go wild. because value proposition lies more in saying we use it than on what it's actually building.
• crnkofe 2mo ago
  All this mindless droning about societal collapse, destruction of jobs, people moving on is really getting old. Sure people have caused mayhem by following (and enforcing) bad practices which resulted in a toxic workplace, a mix of pissed of client due to constantly failing to reach deadlines, unimaginably bad codebase that was a horror to work with and teammates each defending their own turf. LLMs now allow this deterioration to happen much quicker and more effectively. On the other hand the problem can also be triaged quicker and rewritten faster. Pretty much every startup I joined had at its core disastrous code written by students and overworked techies. I can totally see this shitty base being the future base all startups. It'll likely need an army of agents or devs to make sense of all the spaghetti being written. I won't be surprised if demand for devs skyrockets after the first generation of spaghetti western code "matures".
  • johnnyanmac 2mo ago
    >All this mindless droning about societal collapse, destruction of jobs, people moving on is really getting old I mean, it's a huge issue and is still happening. It will be talked about until properly addressed.
• zug_zug 2mo ago
  I think that piece is half right and half wrong. I think it's largely correct that hiring bad engineers is dangerous to the company. But that's always been true, especially those "hack out a prototype, get director applause, and leave it for somebody else to own" people. But management has usually chosen to keep such people around, because they can look good on paper (see how many tickets they closed?). The question is really a management / business-owner question -- will managers/directors stop hiring yolo-engineers? Will they empower engineers to close PRs simply on complexity/size grounds? Will they fund refactors and simplifications as first-class concern? If not, it will be a problem, and I don't envy the engineers who try to be the glue at such a company.
• jadar 2mo ago
  I appreciate that the OP puts his finger on the problem. I think he's right. I wish there was more optimism or ideas about how to solve it, though. How do I fight against it as an engineer? Or, how do I become a "good" engineer? It feels like sometimes the only solution people have is effectively "don't use it."
• tarkin2 2mo ago
  The main thing it's removing is the skills you gain through actual practice, and replacing those with the demand that you subscribe to OpenAI etc to do your job. But, moreover, the demand your company subscribes. But not your company anymore, because you'll probably be replaced by one engineer (and an AI subscription) who's now trying to do your job and about four or five other jobs. And this one engineer will become more and more reliant on AI companies, AI companies that'll go for the throat once they've hollowed out all the skills that used to exist in the engineering market.
• peterjliu 2mo ago
  it seems not just the 'middle', but also the 'lower' classes are getting removed
• wiradikusuma 2mo ago
  I told my (small) team of developers that they're free to use anything to get them more productive: (company-provided) AI, black magic, WFH to avoid traffic, etc. But I also tell them that every human (including myself) is responsible for their own (direct/indirect through delegation) work so we can't say "a genie did that, not me". So far it's net positive for us with AI.
• xvilka 2mo ago
  Now the question is - no one was born good or best engineer/programmer/scientist. Often it was a long path of sleepless nights, daily grinding, failing million times, doing dumb mistakes along the way, the usual package of suffering sometimes called "experience". What is the path now for the next generation of good or best engineers? There will be no opportunities/budget to do the same anymore.
  • doron 2mo ago
    "The underlying purpose of AI is to allow wealth to access skill, while removing from the skilled the ability to access wealth"
    • logicchains 2mo ago
      AI gives the skilled more ability than ever before to create wealth; they can realize an idea by themselves and a few hundred dollars of LLM spending, that would previously have been out of reach for anyone lacking the capital to hire 5-10 people.
      • plaidfuji 2mo ago
        This assumes that writing standalone apps (what is now implied by “realizing an idea” in the AI hype-o-sphere) still has defensible value
      • efields 2mo ago
        I agree with you in theory, but wealth goes hand in hand with relationships. If you can use your skills to make something great with AI in a short amount of time, someone else probably do it too. If they have better connections than you do, they win. Relationships get you farther than raw skill.
      • johnnyanmac 2mo ago
        You make the naive assumption that wealth these days is generated through quality products, talent, and hard work. The wealthy know better and that's why they by far profited the most off of AI.
• markstos 2mo ago
  Perhaps more broadly AI will hollow out "middle intelligence". We could end up with a gulf between those who use AI for cognitive inquiry vs passive delegation. Those who accelerate learning by asking "help me understand this" vs those who relinquish understanding and analytical thinking to AI to complete their work.
• alpha_squared 2mo ago
  Anecdotally, the essay is so spot-on. In my last job, I'd regularly have to review +20k-line change PRs from mid/junior devs only to reach a point where I'd have to just shut down the PR and ask for it to be broken apart. Sometimes, the issue would get escalated and I'd have to speak to their management/director chain. More often, they'd realize that if they spent some time trying to understand how to break it apart, the changeset actually needed to be much smaller and I'd come back to a 400 or 500-line PR to review. In one particular case, a senior teammate of mine went the extra effort to actually explore what the intent of the change is and created a whole new PR for the junior dev that was a simple configuration change of 5 lines instead of the 14k lines they put for review. This is utterly unsustainable and something will give at some point.
• dmezzetti 2mo ago
  As an open source maintainer, I can chime in on this. With TxtAI, I've seen a large uptick in PRs (https://github.com/neuml/txtai/pulls?q=is%3Apr+is%3Aclosed+sort%3Aupdated-desc https://github.com/neuml/txtai/pulls?q=is%3Apr+is%3Aclosed+s...). While the extreme verbosity of Claude messages and commits is very annoying (plus the constant defending itself on why it's a bug), I do think it's a positive that more people are enabled. It does require reviewing the PRs. Some can be tricky just like a human. For example I did merge this PR (https://github.com/neuml/txtai/pull/1136 https://github.com/neuml/txtai/pull/1136) and it would have completely broke search. But a human could also do that. From an open source standpoint, I say the more the better. You just have to be willing to do the work to review and no not just having AI agents to review what the AI agents are submitting. There still needs to be a human in the loop, if you care about quality.
• wojciii 2mo ago
  I got a person from my small team fired before the sommer holidays. Not that I wanted to, but he didn't deliver the quality that I was expecting from a thinking human with an engineering degree. Adding AI to the mix just made things worse. I'm still finding issues in the codebase/documentation that I need to review, test and fix. The replacement is being trained. I made sure that, while I expect them to use LLM supported development .. they own their contribution. This is going to be a fun ride.
• vivzkestrel 2mo ago
  - unrelated but from your blog - you have a very nice article on how llms work here https://blog.florianherrengt.com/how-llms-work.html https://blog.florianherrengt.com/how-llms-work.html - but in your diagram titled "Word vectors plotted in semantic space" dont you think you need to add arrows to show where those vectors are actually pointing? - because i dont get how you arrived at this Using vector arithmetic, you can calculate: woman + (uncle - man) = aunt without seeing the math vector directions
• asveikau 2mo ago
  This subheading popped out at me: > The new AI economy I don't know if this phrasing is intentional, but it gives me a chuckle. The dotcom boom was called "the new economy" about 26-28 years ago.
• deleted 2mo ago
  [deleted]
• thraway3837 2mo ago
  Interesting article, and it makes a lot of salient points. I think I can agree with most of it while also arguing that I don't think good code has ever had an honest measurement of quality. From an end user perspective, the end product either works or doesn't. Working terribly is the same thing as doesn't work and working well is the same as works. What AI changes is the actual code part. The actual code lines output by AI is identical to or better than the best programmers. The systems design, architecture, QA, integration into existing legacy systems, to just name a few, is where the strengths and skillset lies. In order to be a good engineer, you have to be a systems thinker. AI or no AI does not change that. The entire picture has to be taken in to account, and I think this is going to obliterate the vast majority of engineers who cannot or don't want to think about systems. It's no longer about putting on your headphones and outputting code. It's about having to interact with other humans, systems, architectures, organizations, and an API or MCP is not going to help with that. I truly do feel bad for terrible older aged engineers, and the young new grads. I think it's unfair that a lot of new grads were told that CS was a great career, only for them to start their freshman year before AI, and then graduate when AI coding is in full use at nearly every workplace.
  • Joel_Mckay 2mo ago
    > I don't think good code has ever had an honest measurement of quality. Bad workmanship writes bad code in any language. Typically the "easier" the compiler is to use... the more complex the failure mode. =3 This list of rules applies to most languages: https://en.wikipedia.org/wiki/The_Power_of_10:_Rules_for_Developing_Safety-Critical_Code https://en.wikipedia.org/wiki/The_Power_of_10:_Rules_for_Dev... A bit of history where these rules came from, and why they matter. =3 "Why Fighter Jets Ban 90% of C++ Features" https://www.youtube.com/watch?v=Gv4sDL9Ljww https://www.youtube.com/watch?v=Gv4sDL9Ljww The basis of the cited 10 rules helped form many standards for reliable code: https://www.stroustrup.com/JSF-AV-rules.pdf https://www.stroustrup.com/JSF-AV-rules.pdf "Reflections on trusting trust" (Ken Thompson, 1984) https://dl.acm.org/doi/10.1145/358198.358210 https://dl.acm.org/doi/10.1145/358198.358210
• rckt 2mo ago
  > Good engineers have become more valuable because AI lets them move much faster. They don't need as many people around them just to do the implementation work anymore. This would be true if the goal was to get good working code faster. But the actual goal is to get any code faster. So, in reality, it doesn’t matter whether you are a good or a bad engineer. It just amplified how good you are at manipulating the hiring process with your fine tuned resume and how smoothly you can talk your way through.
  • florianherrengt 2mo ago
    [dead]
• lilerjee 2mo ago
  Rubbish article, waste of my time. No confirmation for the title, rubbish arguments and logic. > Good engineers have become more valuable because AI lets them move much faster. Bad prediction. This is likely another AI marketing article.
• johnsmith1840 2mo ago
  Agree with the article the way I think of it is basically like before AI good engineers put in effort either currently or over cumulated years of experience. A bad engineer has been lazy for years and will never change. You likely have experience with this already first hand. Ever had a lazy day and just hit "yes" "continue" on the AI over and over? I've had to revert entire days of work because I was so burnt out I didn't put effort into the design. A good rule of thumb though is if an AI can't solve the bug and fixing it creates more you have a bad abstraction and architecture that needs a gutting and rebuild from near scratch.
• qwertyforce 2mo ago
  I think the worst part is that some companies may be okay with it. They will pay attention only when it's messed up beyond repair. And it’s possible that fixing it will be a task for more advanced models, not humans. Do they win or lose at the end of this martingale? I am not sure
• liendolucas 2mo ago
  I have witnessed first hand this and must say is a disaster, the person that came up with a fix to an issue that I didn't understand tried everything to convince me that the automated fix works. Indeed the fix did work, but when I asked him to explain me the problem and the fix he started to use the prompt to get answers. At that point I just let it go, the only thing that I mentioned later on is that I'm ok with pushing that to prod if that was ordered to me but I'm not responsible for it. I prefer to keep the bug live until I fully understand the problem, reproduce it, come up with a solution and maybe just maybe perform a check against what a computer generated. Please note that the bug came from a real human code base but being complex and not familiar with that part of the code (moreover the code was handed to us without any type of support/documentation) rendered me in a weak position where I couldn't come up with a solution so far. How can someone trust so much a computer generated hotfix without fully understanding a problem is what still baffles me. Still resisting to use any aided coding, no LLM is not going to steal the capacity to use my brain. The day I'm forced to used these tools, the day I quit.
  • deleted 2mo ago
    [deleted]
  • efields 2mo ago
    This is a problem for sure. I don't care what writes the code, but if I commit it or approve the merge, I need to be able to explain it, full stop. I don't need go line by line, just point and explain this does this does that which leads to that. If "can you explain this?" is a question a direct report has to put into a prompt, they are failing at their job.
• lookACamel 2mo ago
  From the title I thought this post would be about something completely different. The post is about splitting the world into "good" and "bad" engineers with an emphasis on the bad engineer. Ok but what does that have to do with the middle class? The post leaves the best part out. What I thought the post would be about is the dissolution of the White Collar Kitchen Brigade The kitchen is run by the Chef but it needs the Sous Chef, Line Cooks, Kitchen Hands to operate. Many software engineers have made a good living acting as the sous chefs and line cooks underneath the rockstar chefs, but with AI companies are inclined to turn the whole kitchen over to the top dog and their AI crew and the ordinary human crew is slowly being churned out.
  • gadflyinyoureye 2mo ago
    I think you and the author are arguing the same point. The middle class offer developer that’s unskilled is going to be on the chopping block. Let’s say that there’s a robot that can now be a sous chef. If you have a good sous chef, you might keep that person. If the sous chef poorly executed her role, the new robot sous chef is probably looking pretty good. Fundamentally this is an hollowing out of the middle class. Arguably these people should not have had a job, but they provided just enough benefit that they weren’t fired.
    • johnnyanmac 2mo ago
      The reality using this metaphor is that you have good sous chefs who are being fired anyway because management thinks the rockstar can just get more done with the robot chef. This distinction into "the sous chef got fired because they were bad" is a distraction from the reality at hand in that the people being cut out are all across the spectrum. There are new engineers who dipped their toe in the water and got cut. There are domain experts of 30 years that architected core systems the company relies on that is cut. Nevermind the aspect that thses sous chefs could one day be rockstars, because no rockstar came straight out of college outperforming their senior's skills decades prior. You're hollowing out whatever isn't profitable at the cost of future talent (and likely the future of the company), but those holding the money don't care. They'll move on the the next company to suck dry.
    • 2mo ago
• Oras 2mo ago
  Agree with the article, but good luck convincing upper management about it. “If it works, don’t fix it” until it doesn’t and we shall see a new wave of software hiring in a year or two. Every enterprise is talking about AI Transformation, and that great with the right expectations. But those who think AI will just make platforms quick with less people and least experienced engineers, will have to prepare for the deinshitification transformation in a year or two.
  • deleted 2mo ago
    [deleted]
• backtoyoujim 2mo ago
  maybe the middle class never belonged there to begin with ?
• KronisLV 2mo ago
  > But once you start storing data there, you can't just remove them. You have to come up with a migration plan, make sure you don't disrupt the system because people are paying to use this every day. You have to think about what you'll do if the migration fails. Make sure you don't end up with orphaned foreign keys. It's just so much harder to fix. Even with the best model you can get. Migration plan? Just ask Claude when shit hits the fan. You'll make a plan when you need one. > By the time you've untangled one bad decision, five more have been merged. I'm slowly (partially ironically/sardonically/nihilistically) adopting a mindset of accelerationism towards the collapse of software development - it was largely done wrong from day 1 and wasn't "real engineering" to a sufficient degree to not lead to the mess that we've been in maybe for the past 20-40 years. The only thing AI did was take away the brakes and press down on the accelerator, we're already headed towards a cliff and have been for a long time. If the code in airplanes and spaceships was developed with the same degree of care and attention as "good code", you'd see those dropping out of the sky regularly. If they built bridges like we build software, they'd fall apart regularly as well. Good code CANNOT hinge on the opinions of some senior dev, or even a group of them - it must be provably good. And if it must be provable, then these checks must be automatable. Bad code (whatever that means, however you'd manage to classify the difference between AI slop and what you want to see) should be IMPOSSIBLE to get into the system at all, due to those automated checks. Be it good enough test coverage, automated checks for usability and end to end coverage of the features, project/domain specific lists of architectural rules (think ArchUnit), needing proofs not just tests etc. We will never have that - our OSes are bad, our browsers and other essential software is bad, our programming languages are bad (the fact that unchecked exceptions even exist in languages is a cardinal sin), same for databases and tbh any other class of software you can look at. This impassioned comment might border on a rant, but my argument is that the past decades aren't the baseline of good code, we'd probably need to spend 10-100x more effort to produce 100-10x less code, but make the existing code bulletproof - there is no reason for more than one OS to exist, no reason for more than one UI framework to exist (or even all of the egregious ways how the web platform was transformed from documents and links to a collection of badly written apps, which eventually infected the desktop with Electron, due to the native GUI development also being severely neglected), no reason for more than one web framework to exist or even more than one programming language to exist in mainstream usage outside of research and looking for the solution to use for the next decade/century of software development. Yes, I'm exaggerating, but the correct answer is probably closer to 1 than to 1000. Obviously that'd lead to death by comittee and some degree of experimentation is necessary, so hey we end up with a new slopped together library every week and I know nothing and nothing works anyways. I wonder if we had ONE high level programming language, whether over time it would have evolved from C++ to Rust (sans odd parallelism), and if it was based on formal proofs, then migrating between language features could have also been fully automated, alongside enough pushback to any feature deemed not worth it. On the other hand, even with all of the world's developers concentrating effort, something like that might be above our cognitive abilities, so probably not - just too hard to reason abuot.
• gambiting 2mo ago
  I work in software and I wonder what companies are letting in those 25k line PRs? If I change more than 3 files at once that's already rising a sea of eyebrows and it will be a week or more to get it through code review. I can't even imagine what kind of supernatural circumstance would lead to anyone accepting a 25k PR at all.
• level87 2mo ago
  It’s difficult to have spent a long time learning something, only for that thing to suddenly become accessible to anyone; something that was once scarce and valuable is now abundant and cheap. There are still machinists doing things by hand, but for real production or prototyping, most will now use a 5-axis CNC machine. It still requires an operator of sorts, but much of the work that once required skilled manual machining is now done by CNC. I think the same thing is happening here; it’s just that the transition is messy. Give it five years, and how we get to the end result will not matter nearly as much as it does now. A messy codebase will be irrelevant, as it will be something managed and controlled by the LLM, written in a way optimised for itself, not for you or I.
  • Chance-Device 2mo ago
    This is exactly right, thank you for saying it. Nice example with the CNC machine too.
  • rootusrootus 2mo ago
    > it will be something managed and controlled by the LLM, written in a way optimised for itself, not for you or I. At that point we might as well invent an LLM-optimized language to use.
  • solomonb 2mo ago
    But CNC machining still requires a ton of physical skills. Its true that you maybe aren't planning out and executing every single tool pass by hand but there is still a tremendous amount of knowledge and physical skill that goes into setting up, indicating parts, etc.
    • spaqin 2mo ago
      I never found a competent metaphor for LLMs taking over. Any tool brought up before still required skill and thought, and deep knowledge of its intricacies.
  • johnnyanmac 2mo ago
    > how we get to the end result will not matter nearly as much as it does now Sure, just wait for the poors to stop rebelling. It will all be over soon.
• deleted 2mo ago
  [deleted]
• docmars 2mo ago
  To the headline: Yep, and for false reasons they'll have to pay for later, alas.
• anarticle 2mo ago
  hahah this is all well and good until the 20k+ line a day person is considered the good engineer, based on kpis alone. Your VPs aren't reading any of that. Bonne chance fired senior! I have depicted you as the 100 line a day weakling, and myself as the 20k+ line chad. The systems at bigcos are too ruthless to risk gambling your career on this kind of reasoning which you have no recourse to. Best to start small teams and destroy them from the outside.
• meander_water 2mo ago
  I think there's a corollary to this. Not only is it hollowing out the middle class, it's preventing the junior engineers from stepping up to the senior level. Everyone starts off as a bad engineer. Just like any other profession, you to make lots of mistakes to learn. But now you're less likely to get wisdom from another human to build up the knowledge and experience you need. And more likely to delegate the hard stuff to Claude so you don't learn from your mistakes.
• rootusrootus 2mo ago
  Do we yet have actual, irrefutable evidence of SWE job losses attributable to successful implementation of LLM coding agents? They've been around long enough and management has been horny enough about the whole thing long enough that we should be able to point to some notable examples.
  • ex-aws-dude 2mo ago
    Literally none yet people keep stating it like it’s fact Every layoff just automatically attributed to AI even though they have nothing to do with it
  • antinomicus 2mo ago
    So far my experience has been management shoving ai haphazardly down the throats of any semi technical person across the board, resulting in a fragmented hodgepodge of vibe coded frameworks and “ai apps” that pile on more requirements for more human attention to make those apps at least look superficially functional to management, than actual reductions in man hours saved by those vibe coded crApps. I believe wholeheartedly that things like Claude code bring immense value but to management types they aren’t visible enough to prove their “ai first” narratives resulting in a bunch of crap they have us build that look and seem smart but in fact are just slop we have to deal with the consequences of. Good for job security I guess, but I’m getting pretty tired of it all.
    • rootusrootus 2mo ago
      So far I'm finding that in a good subset of my regular work Claude can be pretty useful and will speed me up. But I also drive it with a heavy hand. Strong expectations, I know what I want, what success looks like, and I steer it to give me that. Conversely, the product guys I work with are adept at producing proof-of-concept tools that look really good. Fake data, runs entirely in a browser, but conveys their goals way more specifically than Balsamiq ever good. And I think this is a great use case for Claude. But what ain't happening here is product guys producing code that would go directly into production. And even if it could, they're not in a position to provide tech support or debugging when it breaks, so they don't want to be in that position anyway. Nobody can really predict the future very well, it seems, but my personal best guess is that we end up moving the boundaries of what we work on and how, but the need for humans isn't going to go down. As magic as LLMs look sometimes, I constantly run into reminders of how much it relies on how I phrase a prompt when it delivers any kind of answer. That influence really drives how satisfying the results are.
• mt97 2mo ago
  How can I make myself better, asking as a middle swe
  • bibimsz 2mo ago
    ask claude
• douglee650 2mo ago
  First day of work, immediately Ultracode refactor the entire codebase, do a massive 800k line force push to main, git comment, "Hey guys! First day, first commit -- fixed codebase with Claude. Hope this works!"
• omosubi 2mo ago
  I forget the economics term for this but doesn't an improvement in tools result in little net change because everyone across the industry is given effectively the same leg up? Doesn't this mean that things will mostly stay the same employment wise? Most people aren't 10x engineers even with agents. Certain things are true: most products need someone on call 24/7, a group of people who know how to support a product (with varying degrees of knowledge), someone who plans what to build, someone who builds it (usually different people), inefficiencies in communication, etc. at least at the company I work for, agents have all largely improved these things, but by no means eliminated them. So it seems like things will largely be the same. There are only so many incredible engineers out there. They'll become more and more valuable but they were valuable pre ai. It's not like the industry will consolidate to only amazing engineers.
  • Joel_Mckay 2mo ago
    LLM are worse, papers have shown it can actually rot peoples skills by 17% at debugging tasks. It actually makes people stupid, and 250% more confident it isn't enshitification. https://www.youtube.com/watch?v=axOcn--n_lM https://www.youtube.com/watch?v=axOcn--n_lM Some feel more productive, and we shouldn't kink-shame peoples cognitive dildo. =3
• bwest87 2mo ago
  Has anyone seen any tools for enforcing that people understand each PR? It feels like there's a new missing piece here that is like CI for humans, where you as the code owner need to basically pass a test (auto generated by AI) about wtf is going on with this PR and why. If that quiz isn't green then you can't ship it...
  • gnarlouse 2mo ago
    this might be the only comment on this post worth reading, much less the article... seems like a petty easy construction, proof engagement kinda thing
• deleted 2mo ago
  [deleted]
• gnarlouse 2mo ago
  If there's a real existential pressure on a certain group of engineers, those that escape with their employment will carry evolutionary DNA with them (along with a substantial helping of pure luck) in the form of experience. Those that don't will disappear. Nothing else this article says matters much in my opinion. If you're concerned about something, do something about it. AI is still just a tool.
• aussieguy1234 2mo ago
  > bad engineers were always a liability So. AI Makes good engineers better, more productive and able to deliver well designed systems. But it makes the bad engineers 10x worse. Before, they had negative productivity in a team environment. Now, its 10x negative productivity. The mess they create as one person might need 10 people (and their AI's) to clean up. I would also put people who don't know how to code in that bad engineer basket. They would be delivering code they don't understand, accepting unnecessary complexity etc just like your standard bad engineer.
  • platevoltage 2mo ago
    Maybe it does make good engineers better, but that is meaningless when that good engineer has an idiot manager telling them how and when to use AI and judging them based on token usage. You still end up with the same result.
  • bibimsz 2mo ago
    > ... accepting unnecessary complexity you think theyre not going to fix that? somehow elite humans are the only ones who can ever reduce complexity? the tooling is in its infancy. this is the worst it will ever be.
• ltsui 2mo ago
  I thought this was a good read. From my experience and to my dismay, what is considered a "good" or "bad" engineer/developer can be surprisingly subjective. I completely agree that an engineer should never submit a massive PR and instead break the work down, question, and understand the AI-generated code. I also agree that any reviewer should push back on being asked to review that and request the PR to be divided up. Unfortunately, what I've seen happen is that someone else with more power in the organization might find that PR fine and approve it and management might be raving about how good (fast) said engineer is. Those weird bugs which appear down the road get offloaded to other engineers. Faced with that situation repeatedly, most people would find it sensible to resign. Which leads me to another point: if you leave, it will likely be difficult to land another job assuming that companies will impose a ridiculous interview process in fear of a bad hire which will be increasingly expensive as the author argues. I realize that this is nothing new, but if there are fewer middle-class engineering roles, then I expect that these existing problems to become amplified.
• mrheosuper 2mo ago
  >If all they needed was someone who could turn a specification into working code, why were they paying that much when they could already get it done cheaply elsewhere? That's when companies began starting to outsource their work to much cheaper countries
• a2ff6eeb0 2mo ago
  It's removing all classes, or at least compressing them towards the bottom.
• m3kw9 2mo ago
  This is why I think if you are need a 20x plan to code/do software engineering, there is no way you will read most of it, and it is likely 100% slop. A rare few can use it and not create a mountain of tech debt in a few days of use.
• crossroadsguy 2mo ago
  Few years ago this very AI/ML created a frenzy and CS graduates started becoming many fold. Little did they know…
• Animats 2mo ago
  There's a more general problem. We need to figure out how to use LLMs and still have decent code quality. One possibility is to have firmer APIs for known components. APIs that come with the entry and exit conditions for proof of correctness. That gives an LLM a hard definition it can work to meet. This isn't as bad as it used to be. We may be able to use LLMs to create entry and exit conditions from specs written for humans and from unit tests. Code is cheaper than it used to be, but so is formalism. This may be a way to put firewalls around AI slop.
  • unified101 2mo ago
    It's your code review process (with or without agents). If you don't hold this fort, the battle is lost, and the repo is going to devolve.
    • Animats 2mo ago
      What I'm getting at was covered in an article yesterday about the end of abstraction. There's an argument being made for layer-free software, where everything is one big blob of code, created and understood only by an LLM. The software is modified only by re-prompting. There are a lot of people edging around this concept, but it's not solid yet.
      • unified101 2mo ago
        Can you point to any place/post making this argument? I'm an active lurker here, and have not seen anyone arguing for layer-free/blob-of-code type of workflow. The fact that some teams find themselves there is simply a realization of what I stated - inactive maintainership by not taking code reviews seriously.
        • Animats 2mo ago
          I saw that go by on YC two days ago, and it scrolled off fast enough I can't find it. They were talking specifically about AI tools, as in avoiding harnesses and letting the LLM do more of the job.
• peng_gy 2mo ago
  next, will be sensior engineering
• rsanek 2mo ago
  > You were never expected to understand every service and every database. But at least someone did and would explain it to you. This hasn't been my experience. Especially when it comes to enterprise software, eventually everyone that was involved with the design of and iteration on a system will have left the company. Yet, often those systems need to continue running because they support "legacy" customers (who sometimes actually tend to be more economically valuable to the company than the customers on the shiny new system). Before AI, in these cases you just had to dive into the code and start trying to understand it yourself from zero. Usually, you would come to a very limited understanding of the system, just enough to fix the latest bug or keep it running until it hit another issue. I'm not sure why it's necessarily worse to rely on an agent to do this for you these days.
• mancerayder 2mo ago
  I'm simultaneously frustrated and I see a business opportunity - I now know that we senior folks are very far from replaceable - and soon there might be consulting to fix big problems. No one will say it's AI's fault necessarily - you'll just be living with painful complexity that works for a startup or an individual entrepreneur but not in an enterprise environment. To wit: >The person adding Kafka should have been able to explain exactly why it was needed. Here it is. People who don't know what they are doing are adding infrastructure layers they don't understand, can't envisage operationally in the future, and missing scalability. I'm seeing this. In fact I'm spending hours a week fighting it. I had to set up a call with a senior developer recently to explain why his prescriptive attempt to make infrastructure changes in his project can't be done with Claude like he did it. It's playing wack-a-mole as the "velocity" has gone up of changes, and it's promulgated by every manner of product manager and senior developer under an attempt to please the brass. >The person who built the feature should have been able to explain where the data came from without sending a link to a Claude conversation. And they won't - because it's too embarrassing when you see what Claude responded with and someone failed to question. We're in a new era, that's for sure.
• hyfgfh 2mo ago
  I'm sure everyone reading this article thinks of themselves as a good engineer.
• jeffybefffy519 2mo ago
  AI will divide computer science in two: 1. Normal Computer Science as it exists today, just much fewer doing it due to job supply dropping off 2. AI driven Product/Application Engineering, bulk will go here and the course will be shorter and move up the technical stack. This is the only way I can see it playing out at the moment, because AI has completely eaten away the need for juniors and its also made it hard to train juniors since they just want to yolo it with CC all the time.
• zombot 2mo ago
  > But what's the problem then? Just use AI to fix it. Even if that were feasible in a sustainable way (i.e. LLM-generated code wouldn't drown your code base in technical debt over the mid- to long term), the asymptotic end state of this is that the LLM provider owns the means of your production, not you anymore. How can anyone in their right mind run into this obvious trap? > By the time you've untangled one bad decision, five more have been merged. And then there's that. What's the value of all this "speed" when it destroys the most valuable thing you have? > At some point, someone still has to know what is going on. And that's the most valuable person on the team. The best you can do is see that you keep being one of those.
• t_e_s_t 2mo ago
  Hello
• pojzon 2mo ago
  [dead]
• brailsafe 2mo ago
  This is something I've been concerned about. Out of work again for the something like the 7th time this decade, I'm not sure I even care to try and get another one. Unless a place is super low key and actually tests relevant skills, even with kore experience under my belt than last time I ran that gauntlet, I believe companies are likely to be even more conservative than they used to be, which was already comical. I don't believe I'm incapable or a detractor to a team, but the pressure to try and prove it in this economy and in this timeline feel... not really worth it exactly, especially when there's likely to also be pressure from management to move faster and take less time or affordance for actually thinking about what's being done. It feels like what I'm facing is a mountain that could be double the size it used to be, and that has a summit in the middle of a forest with no view. Working on a small, existing, established product that can gradually be improved upon while aided by LLMs if necessary seems like the best place to be. Starting something new (not that I have any legit worthwhile ideas or the resources to pursue them) seems pointless because people are shitting out poorly designed AI slop constantly and poisoning the market. But what do I do instead? Trades programs are already waitlisted or require another 5-10 yrs to earn something worthwhile. Transitioning to anything else seems like a tenuous prospect. I fear that unless I get incredibly lucky, the last job might have been the last chance to earn a living that made any sense. To be clear, I'm not giving AI more credit than it's due, and this article describes the reasons for that which are valid, but the perception that they're magic engineer replacers is more important than reality. At least I can hope that the housing market completely crashes or enough crap code is produced by opportunists that I can ride it out, but other than that it's a confusing time.
• jimmont 2mo ago
  Clearly that article shipped to production without QA. Having no testable definition of good, it must be bad. Fired.
• yohamta 2mo ago
  In Japan still many system integrator company that large corporation relies on continue using waterfall approach. They keep to out source a lot of engineering work for making design documents, manual testing, etc. They would keep to hire many middle class engineers.
• sagabai 2mo ago
  I feel like it might remove not exactly the middle class, but entry level (or honestly middle too) that had only skill for their careers, which is coding, applying very little judgement.
• harrouet 2mo ago
  Inspiring article, I will keep the following bits: - with AI, bad engineers (bad designs?) lead faster to catastrophe - Frontier AI companies pay their SW engineers very much --> we need highly-skilled sw engineers and the lesser ones will get out. Kind of what outsourcing did but x100. As a manager, I'll still have to think how I grow young SW engineers to top SW managers.
• ChrisMarshallNY 2mo ago
  Hi Florian, Sorry to post this publicly, but there does not seem to be any other way to contact you. Your GH page is fairly locked-down, and the link there, is dead. Your “Hire Me” and LinkedIn links in your blog are kaput (for me). It may have to do with UK LinkedIn not talking properly with US LinkedIn. I can find your profile there, but not through your blog links. @dang @tomhow I may ask you guys to delete this, if it gets ack'd.
• CM30 2mo ago
  I think this might be the key point to be honest, though not quite in the way the article suggests: > My bet is that AI pushes salaries further apart. To be employable, there's a bar you have to clear and that bar is whatever the current best model du jour can do. Since well, there are a lot of jobs in the tech industry that for all extents can be 'solved' with AI. Like if you're developing themes and plugins for a CMS (like say, WordPress), something like Claude can do a very passable job at that exact type of work. So, only the more senior developers are even needed in that type of work anymore. And even they only need to review what the LLMs provide and fix issues maybe 10% of the time. Hence the most basic, most entry level friendly engineering opportunities are likely about to be decimated. If your work involves building simple themes and plugins, managing the website of a small to medium sized business or being contracted to build sites for mum and pop companies, then your job security right now is questionable at best. Being better/more skilled than AI is basically the bar you need to clear to find meaningful employment in this field now.
• BatteryMountain 2mo ago
  Chickens are coming home to roost boys. All that tech debt needs to be repaid NOW. All your holes (security) needs closed. You will not able to "fix it in production next week" anymore. Only "real" developers will be able to keep up with the onslaught that has just begun. The industry will consume itself in the next two years.
• foxtrot8672 2mo ago
  this article sounds like a lack of discipline rather than an issue with AI
• jreynar 2mo ago
  AI may indeed lead to a barbell shaped distribution - lots of people with modest skills and the need for lots of awesome people. But I don't think that's necessarily a bad thing. One of the problems with the "middle class" in the past was that there were lots of mid-level jobs in big companies but people hit a ceiling and couldn't progress. Maybe the middle hollowing out will lead to more jobs with significant opportunity and responsibility rather than ones where you get trapped because you weren't at the company early enough or all the top jobs are filled.
  • Folcon 2mo ago
    This is an interesting position, what makes you believe that a decline in positions in the middle would lead to an increase in positions at the top vs just more people stuck being on the bottom rungs of the ladder?
• trakkstar 2mo ago
  This piece is so god damn spot on. I have recently been raising every single one of these exact issues in our team. AI prerequisites good working practices and ways of working more than ever before. And people need to own their contributions, no matter how they produced them.
• uhhhd 2mo ago
  [dead]
• manos-saratsis 2mo ago
  Fully agree on the interpretation. Changes are massive, we checked 100k+ OSS PRs and we see plenty with 1k+ lines of code. And the bigger the PR is, the longer the time is to review and the highest the chance of rejection https://dromeas.ai/blog/pr-vs-trunk-what-code-review-actually-looks-like https://dromeas.ai/blog/pr-vs-trunk-what-code-review-actuall...
• sleepycat801 2mo ago
  > This was already happening before AI. But now, a lot more companies that previously might have taken many years to reach an unmaintainable state can get there in just a few months. And who is going to want to fix that? Maintainers and systems people were the first to be laid off, by management who never valued the "cost centre" they represented, and the few remaining are trying to fight gravity and will likely take the blame when the systems they oversee fall in a heap. Any new hire knows they will spend a few years building a mental map of institutional knowledge, only to be tossed on the scrapheap as soon as the system is working again. If companies want to develop internal software as they appear to, they need to stop defining business processes in code, and certainly stop defining them in Jira tickets. Middle management has outsourced so much of their work to the software or operations departments and now its about to backfire.
• prima-facie 2mo ago
  > "Didn't you build this like... last week?" This captures the essence of AI generated work Vs your own work. AI generated work just doesn't seem to persist in my memory. If I design the application model myself then I can play around with it in my head even when I'm not at my desk. I know it inside-out. If the LLM generated it then I very likely forget it the minute I stepped out of the office.
• iyanuashiri 2mo ago
  Hmm
• SpiralSource 2mo ago
  "This project has become so convoluted, with so many layers and services, that no one on your team could possibly start to understand what's going on." Sounds like A.I. in general...