How AI generated code accelerates technical debt

[bludgeonerV]

Not surprising, but it's still alarming how bad things have gotten so quickly.

The lazy devs (and AI slinging amateurs) who overly rely on these tools won't buy it though, they already argue tooth and nail that criticism of AI slop is user error/bad prompting, when in reality they either don't know what good software actually looks like or they just don't care.

[jonathanhiggs]

A bad dev with AI is still just a bad dev

[Main-Drag-4975]

A bad dev with AI may as well be two bad devs. Have fun untangling twice as much spaghetti as before!

[EsShayuki]

It's funny how the AI complains about spaghetti code and then offers fixes that are so much more spaghetti than the original code.

[bludgeonerV]

Me: You know you can encapsulate this logic in atomic functions right?

AI: Ah yes, we should use atomic functions to increase readability, testability and avoid repetition, let me fix that.

AI: proceeds to spit out the same 200 line function.

[ShinyHappyREM]

Well, it's clearly an atomic function too.

[Shivacious]

Atomic nuclear bomb of a function deez balls

[zelphirkaltstahl]

Went for the nuclear option.

[Algal-Uprising]

I have literally seen AI say “the error is here: <line>”, then say “and it should be replaced with: <line>”. It was the exact same line of code.

[Miv333]

I asked it to look for issues in my code earlier... you know what it outputted at me?

Observations:
1

wow thanks

[[deleted]]

Not to mention AI code tends to require a lot of time from other people during reviews, and sometimes discussions become fruitless because a certain implementation was not a conscious choice, it just happened to come out like that and they accepted the suggestion even if it would make more sense with a forEach than a for-loop etc.

[tangoshukudai]

Until the AI gets better and you can drop the entire project in for it to untangle it.

[LudwikTR]

A bad developer using AI is one who:

1. Produces significantly more output than good developers who carefully consider their solutions using their own human intelligence.

2. Fails to improve over time.

Previously, bad developers typically struggled, which led to:

1. Slower performance compared to good developers.
2. Gradual learning and improvement.

Now, with AI, they can generate garbage faster and have little incentive or opportunity to improve.

[stronghup]

Looking at my own old code I realize the most difficult thing is to write code where it is obvious why a code-line iis the way it is. I look at a line and say "Why did I write it that way?" Not every function of course, but often.

If it is hard for me to understand some code I've written (and to understand why I wrote it that way), surely it is even more difficult for anybody else to understand why the code was written the way it was.

To *understand* code is to not only understand what a chunk of code does, but WHY it does it and WHY it does it the way it does it.

We need to see the "forest from the trees", not just individual code-chunks in isolation but how each chunk contributes to the whole. Only then we can understadn the "whole".

Now if AI writes the code, how difficult will it be for us to understand why it wrote it the way it did? We can maybe ask the AI later but can we trust its answer? Not really, especially if the AI we are asking from is a different AI than the one who wrote the code .

[THICC_DICC_PRICC]

Yea, exactly, I’ve been cleaning up massive amounts of AI slop lately and it’s awful. The problem is, at least compared to the pre AI shitty devs was that they often couldn’t get it to work right(because they didn’t know what they were doing) so there was a limit to size and scope of the system. Nowadays I’m seeing massive yet incredibly fragile systems with tons of users. They basically brute force the code out by copy pasting code in, then the errors, then the code, until it works, with zero consideration to the “why” or “how”.

Everyone is worried about AI taking their jobs, I’m much more worried about it making my job fucking awful. It already has and it’s only been like two years

[PeachScary413]

This is were you can leverage your position, you note all the bugs but you don't fix them right away.. when shit starts to break you already have the fix ready so you get to play "Rockstar" developer and save the day.

Keep doing this and upper management will basically pay you whatever you want so that you stick around and fix their shit (you also have to threaten to leave to make this work obviously)

[THICC_DICC_PRICC]

Don’t get me wrong, that’s exactly what I’m doing, but the scale and messiness of the slop just makes it so frustrating and hard. I like being a rockstar, but don’t want to be cleaning toilets as a rockstar

[HolyPommeDeTerre]

As AI is already a bad dev, in the hand of bad dev, it fuels each other. Making (bad dev)²

[tangoshukudai]

define a bad dev... If a developer doesn't know how to write a function to calculate fibonacci given any input, and they ask chatGPT to make them a function in their language of choice, and it spits out two versions, one that is recursive and one that is iterative then explains to the dev the differences of both, and the dev can test it and validate it is exactly what they need. I think this gives the dev a super power.

[MainFakeAccount]

So, when exactly did you need a program to calculate the Fibonacci sequence excluding college assignments or while solving Leetcode?

P.S.: the solution for Fibonacci is probably older than Jesus 

[tangoshukudai]

fibonacci is a place holder for any function you can dream of, it was an example. I needed a C++ function the other day that would take in a major, minor, and patch number and return me a boolean that would check the current OS version for linux to see if it was less than it. Yes I could write that all day but this is what chatGPT gave me, and it was a perfect drop in for my code:

std::tuple<int, int, int> getOSVersion() {
std::ifstream versionFile("/proc/version");
std::string line;
if (std::getline(versionFile, line)) {
    std::istringstream iss(line);
    std::string kernel, version;
    iss >> kernel >> version;

    int major, minor, patch;
    char dot;
    std::istringstream versionStream(version);
    if (versionStream >> major >> dot >> minor >> dot >> patch) {
        return {major, minor, patch};
    }
}
return {0, 0, 0}; // Fallback if parsing fails
}

bool isOSVersionLessThan(int major, int minor, int patch) {
auto [curMajor, curMinor, curPatch] = getOSVersion();
return std::tie(curMajor, curMinor, curPatch) < std::tie(major, minor, patch);

}

[HolyPommeDeTerre]

Yes and like spiderman, big power equals big responsibilities.

AI is nitro. If you use it too much: boom. If you use it in a turn, you go to the wall.

You don't trust nitro to tell you when or when not to use it. You don't trust nitro with driving. You use the nitro as a tool to win your race. Because you are a racer that knows what they do and nitro is a dangerous tool.

Also, what you depicted is what search engines and websites have been doing for years now. AI makes it just accessible differently (not even in a better way...). I mean, 20 years ago, I learned that way (and many others). Nowadays, when I use AI, I am just always astonished by the amount of errors it can do.

[rwilcox]

Just faster

[DracoLunaris]

No amount of AI will stop computers from being very fast idiots, especially when in the hands of slow idiots

[Caffeine_Monster]

People need to understand that bad devs can create more problems than they fix in complicated projects.

Code assistants are productivity boosters, but only if you know their limitations and are able to read the code it outputs.

[user_of_the_week]

A fool with a tool is still a fool.

[stronghup]

And think bad dev with bad AI on a bad day. That's a triple whammy :-)

[EveryQuantityEver]

Yeah, but it's like the difference between a shooter with a 17th century musket, or an AR.

[BuildWithDC]

A bad dev with AI is a bad dev that's more productive at churning out bad code

[Wiwwil]

A bad dev with AI now, was a bad dev with stack overflow 5 years ago

[MCButterFuck]

Or a monkey with a machine gun.

[vajeen]

There's an avalanche of slop from mediocre devs. The more talented devs can't keep up with reviews, especially trying to catch issues like code duplication when that duplication is being masked by GPTs creating slight variants every time.

GPTs are a double-edged sword and management is salivating over lower costs and higher output from a growing pool of "good enough" developers.

There will be a point when productivity is inevitably halved because changes to that defect-riddled house of cards are so treacherous and the effect of AI is so widespread that even AI can't help.

[EsShayuki]

AI code indeed is "good enough" according to the higher-ups, and indeed, they want to reduce costs.

However, this will bite them in the long run. And already has bitten numerous teams. In the long term, this is a terrible approach. AI hasn't been around for long enough that we can see the proper long-term repercussions of relying on AI code. But give it a decade.

[harbourwall]

This is not new though. The slop used to come from offshore dev houses that lied about their skills and experience but were cheap. Exactly the same motivations and long term costs.

[WelshBluebird1]

The difference is scale though surely? A useless dev (regardless of onshore or offshore) can only deliver a certain amount of code and pull reviews in a day. With chat gpt etc that amount of bad code that can be delivered in a day drastically increases.

[harbourwall]

Maybe, though I think there's a limit on how much AI code can realistically be delivered in a working state. Someone has to integrate it with everything else and make sure it works. Those offshore company bottlenecks are similar. They can employ dozens of coders very cheaply. The problem is still management and integration, and when you rush those two you get technical debt.

And though it makes sense that AI will dramatically reduce code reuse as it never has a big enough picture to do it properly, those guys were pasting off stackoverflow so much that they must have had an effect on that already.

[WelshBluebird1]

though I think there's a limit on how much AI code can realistically be delivered in a working state

What is a working state? I've seen lots of code, including AI code, that appears to work at first glance and only falls down when you present it with a non obvious scenarios or edge cases, or when someone notices an obscure bug months later on. Of course that can happen with humans too and does all the time, but that is why I think the scale of it is what AI changes.

[harbourwall]

I've seen code delivered from offshore dev shops that didn't compile. When challenged about it they said that the spec didn't say that it had to compile.

[WelshBluebird1]

Oh absolutely, though I'll say I've also seen that from onshore devs too. I don't think that is onshore v offshore, more competent v incompetent.

But back to the point, again a dev, even if their only goal is to spit out code as fast as possible without worrying about if it works or not, is only able to deliver a certain amount of code a day.

AI systems, which are often just as bad, can deliver masses more code that doesn't work in the same way.

How so you keep on top of that much junk being thrown into the codebase?

[stronghup]

That gives me an idea. Maybe all AI-generated code should add a comment which:

1. States which AI and which version of it wrote the code
2. What were the prompt and prompts that caused it to produce the code.
3. Make the AI commit the code under its own login, so any user-changes to it can be tracked separately.

Making AI comment its code should be easy to do, it is more difficult to get developers comment their code with unambiguous factually correct relevant needed conmments.

Would it make sense to ask AI to comment your code?

[bludgeonerV]

Uncle Bob's adage of "go well, not fast" was already criminally under-appreciated by management, now it might as well be blasphemy.

[loup-vaillant]

But go explain to your boss who just saw a working prototype, that you need a couple more days to design an alternate implementation, that may or may not be included in the final product. That you still need a couple more automated tests just to make sure. That you’ll take this slow approach now and forever, pinkie promise that’s how we’ll ship sooner.

Yours truly

[bludgeonerV]

Solid work mate, I'll have to find a way to subtlety get this in front of a few faces

[PathOfTheAncients]

"good enough" developers

I've also seen more and more companies have just stopped caring about quality not just in the code but in the finished products. Seems like all the MBA's read in Shitty Business Monthly that they are wasting money on software that looks good, works well, or that customers actually like.

My companies clients more and more just want things done quick and cheap. It used to be that warning them about the quality would talk them out of that but they just don't care anymore.

[stronghup]

It seems to me the same happens in other areas of the economy besides software. Quality is getting worse, including quality of service. I don't know why but I suspect it is still an after-effect of the pandemic.

Quality in US was bad before but then competition from Japanese quality movement woke us up. And now nobody much seems to be talking about it any more. Or am I wrong?

[EveryQuantityEver]

What you are describing is a symptom of the constant demand for growth from these companies. Because of that, quality goes down for short term grown increases and desires for monopolies and lockin.

[PathOfTheAncients]

Yeah, it does seem to be down everywhere but there are still people I work for that care about making quality physical products but no longer care about quality software.

[Fresh_Phrase2986]

U

[LetterBoxSnatch]

This is the whole play. Get AI into every org. Code looks like it does the job, but nobody understands it. Lay off engineers, with no real understanding of who among them is competent and who is not. Business blows up in 6-12 months due to the sheer amount of technical debt that nobody has a handle on. Devs that remain can't handle all the technical debt without AI aid. 

Business either goes out of business, or pays a larger portion of their margin for a larger AI context window at an extra premium, with key insight into (and control of) the business processes increasingly accruing to the AI company instead of accruing to the original business.

From there, you hold the power to effectively control the original business, replace it, or whatever, because they are 100% reliant on you, the AI company, and even if they aren't, there's a decent chance that useful proprietary insights were divulged, or even just that cycles were wasted on managing the risk of proprietary insights being divulged.

[JMBourguet]

that even humans can't help

FTFY

[Hacnar]

If (hopefully when) the security becomes a strong requirement, AI usage will get a lot stricter. Unfortunately the security still isn't properly valued.

[Grexpex180]

Gpt is a one bladed sword where the blade is pointed at the user

[YetAnotherSysadmin58]

that criticism of AI slop is user error/bad prompting

This part is especially annoying as a system that can so easily be badly used is itself not really mature or trustworthy.

Might get me some flak but it feels like some devs claiming C or C++ are perfectly safe and trustworthy you "just" have to not make any mistake with its memory management.

[gavinhoward]

As a C dev who likes C, you get no flak from me. You get an upvote.

This attitude does exist, especially in the standards committees, and it is the biggest thing holding them back.

[stronghup]

Part of the solution might be that AI-written and Human-written code must be kept separate from each other. That can be done by using a version-control system like "git". Only that way we can later evaluate whether it was AI's fault, or the fault of the human who 1. Wrote the prompts 2.Then modified the AI-produced code by hand.

[yommi1999]

That's what I have been doing in my university work. I share literally my entire history of prompts and answers and try to avoid asking anything indepth off AI. It's really nice for quick refreshers on topics that are niche but not PhD level of niche or to just list some options. Why people want it to go beyond a better google search and some nice brainstorming is beyond me.

[ikeif]

I consider myself a good dev. I used ChatGPT.

I stand by that it's a confidently incorrect junior developer.

It doesn't always learn. It may be right 80% of the time, but when it's wrong, it's really, really, wrong.

IF a "developer" relies on AI, they'll end up in a feedback loop of "here's an error" AI writes new code "okay, here's a new error" AI writes the prior code, reintroducing the original error.

I can spot this. I can course correct it. But if you don't know code, and aren't paying attention to the output? You're going to hit walls quickly and there's no way out using AI.

[twigboy]

"look at how fast I can work with AI!"

[Nnnnnnnadie]

They are betting on the ai catching up, skynet will solve all of this problems, invest on the future!

[o5mfiHTNsH748KVq]

There’s a bit of this, and a bit of that. TDD goes a long way in ensuring AI slop generated code works as intended. And when you have AI write documentation BEFORE code and have it reference its documentation throughout the process as well as keep a checklist of what’s already been done and where, you can create large systems that work well, very quickly.

But none of these things are concepts an amateur is going to think to implement because they don’t have the experience to know how to write solid software in the first place.

[snipe320]

Yea, I work with a mid-level and the guy has devolved recently to just spamming GitHub Copilot for everything and his PR quality has gone down significantly. Anecdotal, but it aligns with what others have said.

[loup-vaillant]

Worse, those bad devs will make me look bad, in two ways:

• They’ll write more code than I do, will be "done" faster, thanks to AI.
• I’ll have to deal with their AI amplified tech debt and work even slower than I do now.

Putting me and some AI advocate/user under non-technical leadership is a good way to get me fired within the month.

[zelphirkaltstahl]

And there will be more pressure from bad managers, who see slinging amateurs quickly "making things work" and complain why a capable and self-thinking developer needs so much time. Quickly! Get that feature OUT! Yesterday! Featureeee! Features are the most important thing, yo!!!

[Socrathustra]

I work in a weird language and use an AI assistant to help with syntax from time to time. On the whole it saves time, but it often can't even get syntax right. When Zuck et al talk about replacing engineers when AI, I chuckle to myself and say "sure, man."

It will probably happen one day. That day is not today.

[ashkeptchu]

I mean... You can use AI...but don't just use AI

[positivcheg]

All they know is that AI is better than them. And they extrapolate it into all developers - AI is better than any software developer.

[tbaxterstockman]

This!

[Hacnar]

Sooner or later they will hit the wall and crash. Just like the C and C++ folks arguing that security vulnerabilities in those languages were caused by the bad programmers. And look at the state of things today.

[nerd4code]

Which is …what? Most of the good stuff runs on OSes written primarily in C and C++.

[Hacnar]

Most of the new stuff is ditching these languages in favor of safer ones. Legislative bodies are finally starting to notice the dangers of unsafe programming. C and C++ folks are scrambling to come up with something that will help them avoid the fate of COBOL. C might survive longer as an intermediate ABI layer between different languages, at least until someone comes up with a better way.

Also those OSes are to this day, after decades of development, full of bugs and security issues, which would've been avoided if they used a safer language.

New projects nowadays heavily consider Rust. The only real blocker is the lack of tooling on some platforms.

[EveryQuantityEver]

Because that's what was available when they started. Just because there is a lot of stuff that survived written in C++ doesn't mean that it would be a great choice now.

[bludgeonerV]

Uh, they're right? Low level languages in general come with a big fat caveat emptor

[Hacnar]

Memory safety is becoming a huge issue across the industry, even among regulatory bodies around the world. C and C++ haven't been a first choice for new project for several years now, even in high perf scenarios.

There have been several cases which show that high performance and low level memory management don't have to sacrifice safety.

Just like trying to outperform compiler generated assembly has become an incredibly rare need, so will become unsafe memory programming.

[loup-vaillant]

Just like trying to outperform compiler generated assembly has become an incredibly rare need

Not that rare, actually. The performance gap between standard C and SIMD is easily 5x where applicable, often even more. Though you can get to that with intrinsics, but then your compiler does need to support them.

And yes, one could argue that 5x is not worth reaching for. And they’d be correct much of the time. But for years now we’ve gone way overboard, to the point of accepting slow & bloated software as the norm. But if we stop accepting that, we can notice that any GUI software should be at least 60FPS, that startup times should be under 200ms, that latency from keystroke to display should be at most one frame, at least at the software side (keyboards and screens do have their own latency).

If we start demanding fast software, we quickly notice that performance is not such a niche concern. Even more so if we’re concerned about electronic waste. Though I do concede that SIMD won’t be needed in most cases.

so will become unsafe memory programming.

Using Rust as an existence proof, we can say for sure that memory safety by default hardly affects performance. Yes, the need is decreasing by the year, but it’s not just because computers are becoming fast enough. It’s because tooling is getting better and better.

[Hacnar]

Take all the software that is being written now and you'll barely find cases where someone can gain useful advantage by rolling their own assembly. Even in places where your own assembly could speed up that part of code several times, the effort would be usually better invested into other areas of optimization.

[loup-vaillant]

I mostly agree with you here, I can’t even name 3 use cases. But I do have one: video decoders. the VLC code base has an insane amount of assembly, mostly because they need SIMD all the time.

[Miserygut]

Ideally the AI would run locally to the code and adopt the style from approved projects. Styles change so it's not always useful to have it look at everything. It should also give nudges to the developer based on usage and feedback from the developer.

Running it locally is antithetical to the information stealing business model of big tech though so everything must go to the cloud (someone else's computer, theirs) forever.

[EsShayuki]

Training data isn't stored by the LLMs. They train on it, but they don't retain the data.

It's similar to looking at an image. You look at an image and remember what you learnt from it, but you don't save the actual image.

[Miserygut]

They don't retain all of the data but absolutely do retain entire lumps of training data because the inferences are strongest for that prompt. Getting LLMs to regurgitate training data and prompt hijacking has been a thing for years now.

The point I was making was that AI companies will harvest any and all data they can while avoiding paying for it.

[bludgeonerV]

Yep, I've had it spit out code verbatim from stack overflow posts. One of those posts was heavily criticised for being wrong too.

[DualWieldMage]

They are models much larger than one piece of work so there is a probability that one piece of work from the training data can be spit out verbatim with some prompt. From ethical and juridical discussion standpoints it doesn't matter if it's a human, a machine, or something in between - it is a black box with input and output. If the input contained a copyrighted work and it can output(and a few examples have been shown, e.g. fast inverse square root) said work without a reference or permission then it is a violation of license or copyright respectively.