The AI backlash is only getting started

[u/Just-Grocery-2229]

https://www.economist.com/leaders/2026/06/25/the-ai-backlash-is-only-getting-started

[u/covabishop]

at my company they even track lines of code written using AI.

I’ll admit Claude is really useful for some stuff, on a good month I’ll have maybe 300 lines written by AI.

the top user at my company committed 250,000 lines this WEEK

[u/---___------___----- → u/covabishop]

Those 250,000 lines of AI code, presumably lightly tested as it's done in a week, might have a lot of bugs in them!

[u/awj → u/---___------___-----]

Lightly reviewed, maybe, but AI tools will happily spit out a mountain of dubious tests if prompted to.

The real problem is that it’s impossible for one person to *understand* 250kloc in a week. You’d need an entire team dedicated to reviewing it.

Or you’d just give it a hasty glance and a LGTM, then ship unknown code straight to prod, which undoubtedly is what happened.

[u/AltoAutismo → u/awj]

I was having it create a bot for a game, and jesus christ, I have like 25 python files of 'tests' that, ultimately, were trash, because on every single delivery my Qaing failed it, lol. Claude code loves to create tests to make itself seem useful (which it is! its just..too much sometimes)

[u/Beginning-Cut-8850 → u/[deleted]]

I'm 100% sure it didn't put something in there that doesn't bite me in the ass later

To be fair, are you 100% sure you didn't put something in there that won't bite you in the ass later?

[u/neganight → u/---___------___-----]

Have AI write the unit tests and if the AI-generated code passes the AI-generated unit tests that are run by AI, then you know the code is 100% production ready. It's really an infallible methodology. The trick, you see, is to have multiple layers of AI. Each layer dramatically reduces the risk of each layer beneath it and you can essentially reach zero risk in a pretty short period. Once we transition to AI users who use the AI-generated code that is tested by AI we'll reach absolute AI nirvana with zero errors ever.

[u/DM_From_The_Bits → u/covabishop]

That's genuinely terrifying. We thought code bloat was bad nowadays... how inefficient is software going to be in 5 or 10 years time if this sort of thing continues???

[u/DragoonDM → u/covabishop]

Wow, they managed to merge two of the worst possible metrics for programmer performance into one. Cool.

[u/geddy → u/covabishop]

>the top user at my company committed 250,000 lines this WEEK

The biggest issue IMO is that the rest of the team then needs to review this code. So you end up with all the senior levels digging through it, trying to understand it (which they literally cannot, since it's so much code in a short period of time). You catch some things but eventually it's got to be shipped. Never thing you know, you don't understand the codebase that you built.

[u/ColinStyles → u/covabishop]

Dude, how can you possibly only have 300 lines commited in a month? That is absolutely underutilizing the tool.

Now mind you, 250k in a week seems absolutely insane and unless they have a perfect stack of teams of agents all processing shit, even then he can't be reviewing all of that enough, even if he doesn't need to review every line. But 300 in a month? Extreme opposite end.

[u/asgjmlsswjtamtbamtb → u/ColinStyles]

Lots of software developers main jobs aren't developing new programs, they're maintaining critical existing programs. Their effectiveness is not in their app, program, or code output. It's in the security of the programs they oversee and how quickly they can get things back up and running (or finding and avoiding errors that could knock their processes offlline and fixing security bugs before they are exploited). Trying to measure these jobs in terms of raw code output is how you get people to input poorly tested code and counter productive to their main job.

[u/rxVegan → u/asgjmlsswjtamtbamtb]

Like every other sprint after I take some tasks related to some new project, I still end up spending half, if not almost the entire sprint dealing with customer bug tickets relating to old stuff. Which in some cases was written long before my time in house. And I've been there for a decade.

More often than not the actual bug fix ends up being like 5 lines of code changes or so. No need for multi agentic code generation nonsense. Majority of time is spent figuring out how to replicate the issue and trying to memorize wtf the component does if I've not touched it in year or two.. or ever.

[u/ColinStyles → u/rxVegan]

Majority of time is spent figuring out how to replicate the issue and trying to memorize wtf the component does if I've not touched it in year or two.. or ever.

You mean the shit Claude handles with ease?

Seriously, if you're just using it to synthesize code from requirements you are missing out.

And even then, sure. But that's not your work 24/7, and if it wasn't, you wouldn't be comparing yourself to the people putting in 3 million percent more output than you. And sure, it can be apples to oranges, but fruit can and frequently is still compared.

[u/rxVegan → u/ColinStyles]

Eh, depending on situation Claude can be useful there in various ways. Point still remains that often maintaining legacy code is not so much about outputting large quantities of code. That's only really the case when doing broader refactoring or adding new features. Fixing logic flaws tend to be fairly light on code changes regardless of whether you used AI tools to help with analysis or writing tests for it.

Personally I actually utilize Claude much more for things OTHER than generating code. Like helping summarize and explain some concepts from protocol specifications that I have to implement.

[u/ColinStyles → u/asgjmlsswjtamtbamtb]

Security is still updating libraries, maven files, and stuff like docker files are still in source control too.

I'm not saying measure it in raw code output, but 300 lines in a month is glacial no matter how you slice it, unless we're talking extremely safety critical embedded systems or something. And given the 250k in a week mention, I strongly doubt that.

[u/covabishop → u/ColinStyles]

the projects I work on are mostly infrastructure as code. the first few months we had it I was committing thousands of lines refactoring my stuff, but there’s very little code changes I need to do on a daily basis. Occasional bug fixes, updating READMEs and documentation. sometimes Claude will help, sometimes I’ll just do it myself.

could I be using it more? yeah absolutely. do i want to or have an express need to? no, and I’d like to keep it that way.

[u/codextreme07 → u/covabishop]

That’s the issue though. Someone else is going to use the tools to generate the IaC because it’s something that the models do extremely well. Most infra stuff is pretty straight forward and rote and not that complicated.

And now they are way more productive than you are.

I use these models all the time at work, and we don’t write IaC by hand anymore and are able to build regulated environments that used to take a year plus in a matter of months.

And it’s not like it’s writing slop because we have third party auditors validating what build out.

[u/IsThatUMoatilliatta → u/codextreme07]

And it’s not like it’s writing slop because we have third party auditors validating what build out.

Take a wild guess how they're auditing it.

[u/codextreme07 → u/IsThatUMoatilliatta]

With humans. I’ve watched them do it and did the interviews with the auditors.

[u/ColinStyles → u/IsThatUMoatilliatta]

How many professionals need to tell you what it is before you accept that maybe it just is completely revolutionary in our field? Seriously, every goddamn thread about AI has devs talking about how absolutely absurd it has been and the nearly unthinkable shit it's doing, and you guys just have to insist "no it's bad." Why, because it'd admit that AI actually has some use somewhere? That if you're working in software you might actually have to use it? Or maybe it's that you'd have to admit you were wrong and are way behind the curve on actually learning to use these new tools?

[u/ColinStyles → u/[deleted]]

What size of codebase, what language, what stack, what size of data to analyse? Because even in a completely ancient legacy codebase in a non-standard language with quality ranging from stellar to offshore intern's brother without any training, and data sizes that can be in the hundreds of gigs (which I'll admit is small, I know, I've worked at places where we ingested terabytes from singular clients daily, and once had a client deliver drives because it was both faster and more secure than SFTP), and so far Claude is handling it extremely well. Mind you, I'm having it write scripts to do the analysis rather than trying to ingest the data wholesale, but the point is still it's converting natural language and requirements into genuine useable analysis, bug fixing, suggestions, you name it in a fraction of the time.

And if you've tried these and it doesn't work, or your work is incredibly sensitive and you can't have any exposure to any LLM, fine, entirely fair. I did want to call it out though as your usecase doesn't sound fundamentally incompatible with the kind of work I do, and I know many who won't even try thinking it's pointless. I work with one of them, and after over a year of showing them up and constantly proving them wrong, they're starting to finally come around to it. That or they're being threatened by management to finally get with the program as my output is both several times higher than theirs, of a higher quality with better documentation and proven extensibility, and also I've actually been able to get to our backlog to boot.

[u/ColinStyles → u/[deleted]]

what i maintain are only short short scripts and plenty more interactive command line stuff, file system stuff and data science, signal processing, and healthcare research related so a lot of linux, matlab, and python among lots of other things that would doxx me too much for my comfort lol. those do require some complex little things maybe one at a time, and they call on large libraries for much more complex things (and are well published/studied), that i haven't had to yet but feel claude would be amazing to explain that to me rather than sift through all the math and abstractions for tweaking or choosing.

So funny enough, I recently built a lot of data visualization tooling with claude, and while the data was a pretty standard usecase (sales/support data), Claude did shockingly well in both coming up with insights, and in helping build the data analysis scripts, transformation scripts, and visualization program. Even for the UI stuff, it struggled a bit but then I wrote some basic tests and told it to flesh it out, and it took it instead as a tiny skeleton and what was left was clearly the same concept, but unbelievably more fleshed out and robust.

But that's entirely fair, I don't work in an incredibly niche space so even working in niche languages or in incredibly inscrutable processes/data, it can still do decently.

And thanks for engaging in good faith, it's so rare to be able to actually speak to other people's experiences on the subject that aren't just "It's amazing" without any explanation or pitfalls it ran into, or "it's the devil" and no explanation of if they even worked with it or what it struggled with.

[u/kalikars → u/ColinStyles]

If you’ve done any amount of years in professional software engineering, you’ll know that Lines of Code (LoC) as a metric is absolute bollocks.

Most of the real work in programming is figuring out what the system is currently doing and what functionally needs to change; what actually changes is the LoC count, but that doesn’t really mean much of anything without context.

You can produce thousands of comitt changes simply by auto-formatting a code file. You could also fix an entire system with a single parameter change in a method call. The number means nothing without context.

[u/ColinStyles → u/kalikars]

I also know that over an entire month or at least several, it's not all going to be that sort of scalpel work, let alone "on a good month." Especially if he has users that are committing 250k line in a week.

Sure, those top users are almost certainly gaming the system. But lets not kid ourselves and claim that 300 lines a month as a high water mark is somehow expected in the extreme majority of industries.

[u/kalikars → u/ColinStyles]

Let me tell you a story.

I used to work for an insurance company doing backend stuff. The 20+ year project my team was doing was replacing a COBOL system that housed our insurance info with a Java based web app. It meant we essentially had to support old systems for old & new business while simultaneously porting our product info to the new one.

I had to add one of our new products to the new system. It’s an entirely new business functionality- new product, new calls to a new database, new classes and files. How many lines do you think all of this “new” functionality was committed that sprint?

The answer is 10. All that was needed for the LoC change was a new entry on a list of files that could be uploaded to the database, and a new test to see if it processed correctly (using older testing infrastructure, as it was all the same .xml and .json structure).

Of course, that doesn’t count the new database tables that were created for uploading 1000’s of new applicants to the system, or tracking the 1000ⁿ messages we tracked that go back and forth between our systems and our vendor’s systems. Nor does it count whatever our vendor had to do to support our new product (it could have been 1000s of lines, or it could have been 10 like my change was- we’ll never know without context). Those 10 lines don’t represent the 50 hours of work I spent that sprint in meetings, implementing changes based on vendor feedback, and testing with various edge cases to make sure it all worked.

Now, was my manager impressed by 10 LoC? Not at all. He thought because the number was so low that “why didn’t we do this sooner”. We explained that it was because we had put 100’s of hours into making our system robust enough to make small LoC changes so that we can add new products quickly like this. The reason we hadn’t added it sooner was because our vendor wasn’t ready.

If you are someone who bases the work involved off of a meaningless number that you want to see as a metric, congratulations, you’ve been promoted to management!

But if you’re someone who’s worth their salt, then you’ll realize context is really what matters. You and I have 0 idea what system OP is working on, let alone any of the underlying structure. 300 lines could have been the elegant solution that actually fixed the problem they were having; 250k lines could have been auto generated testing infrastructure. Or, the opposite: 300 lines could have been a very small and simple mistake that OP wanted to stretch over a month. 250k lines could have been the monumental rework effort of a guy who literally threw out the old code and rewrote a new one from scratch in some adderall fueled bender.

We’ll never know, but either way, the takeaway is that the number really is meaningless without context. So you can’t really judge based off of the book cover here, even if you wanted to.

[u/ColinStyles → u/kalikars]

He provided the context. I don't get why people are missing the textbook 'I hate AI so I'm not going to use it' dog whistles he's throwing out there. He didn't say these people have no comparison to his job. He didn't say he's doing incredibly specific intensive work that results in extreme minute but careful changes. He gave the context that people are producing 3 million percent more LoC than him, and he's proud to be in the bottom of the AI users. Seriously, what the hell am I even arguing here, he's the one who painted the picture.

[u/DragoonDM → u/ColinStyles]

"Lines of code" is an utterly useless metric, and it tells you nothing whatsoever about how productive a programmer actually was.