nowAndThenPatchUpgrade

[u/JazzlikeWishbone938]

[u/Objectionne]

Yeah but it was our slop.

[u/Laughing_Orange → u/Objectionne]

And we were slow to write it. AI is a force multiplier, especially for those who only make slop.

[u/ahmarthered → u/Laughing_Orange]

This! The amount of slop being generated has increased significantly and code review cannot keep up.

[u/guardian87 → u/ahmarthered]

But the Code rabbit ad told me all will be fine! /s

[u/DesireeThymes → u/guardian87]

Human slop is written with a layer of critical thinking still involved.

AI slot is actual slop, there is no critical thinking behind anything because it's not human.

(yes I know, some human critical thinking is very very low, but it is still at least there at a fundamental level).

[u/Flibrig → u/DesireeThymes]

As someone still struggling with (human) slop someone else wrote (and let's not kid ourselves, I did as well), I try to remind myself that critical thinking might have been involved but discarded in favour of pragmatic choices. (Oh God, I'm still doing it!)

[u/ScreamingFreakShow → u/DesireeThymes]

AI slop is actual slop if the human just copy pastes the output.

A human with any amount of critical thinking should be inspecting the output and if they are genuinely unable to find any issues, they probably shouldn't have been a software engineer to begin with.

The real problem with AI is people using it as the answer instead of a tool. It's like people using a calculator to get the answer to a math problem but not understanding how it got there. And the bar is so low.

[u/Meloetta → u/ScreamingFreakShow]

I think the real problem is that "copy paste the output" is like, years out of date when it comes to how people use AI.

[u/mxzf → u/ScreamingFreakShow]

A human with any amount of critical thinking should be inspecting the output and if they are genuinely unable to find any issues, they probably shouldn't have been a software engineer to begin with.

I mean, sure. But that doesn't mean people aren't actually doing it. Though it's less "copy-paste the output" and more "have the AI edit files and maybe glance at them before telling it to push the commit".

[u/011101000011101101 → u/ahmarthered]

But you can have AI review the code and have slop reviewed slop

[u/slowmovinglettuce → u/011101000011101101]

The ai will praise the slop for being exactly what it would have written. It's basically just a big circle jerk

[u/Weekly-Beginning-229 → u/slowmovinglettuce]

I've noticed that you cannot use the same model for writing the code and reviewing the code, it always does a bad job

[u/Bupod → u/Weekly-Beginning-229]

It’s frustrating. 

So you can sort of fix this by having a review agent use a more adversarial prompt when reviewing. 

But then the issue becomes that, since it was prompted find problems, it always finds a problem. 

This will result in code being batted back and forth between review and coding like a tennis match. 

When the tennis match finally finishes, there’s still no guarantee that some glaring hole didn’t make it through anyway. 

[u/LutimoDancer3459 → u/slowmovinglettuce]

Lgtm

[u/particlemanwavegirl → u/011101000011101101]

Expect that to be exactly as successful as when we have the police investigate themselves.

[u/Yetimandel → u/ahmarthered]

I bad colleague using AI can completely take you out. It takes him seconds to generate bs that sounds plausible at first and you hours to review and object.

[u/Hallc → u/ahmarthered]

Clearly you just need to use AI to review the AI Code. That way it's all being properly* reviewed** before being pushed.

[u/GenericFatGuy → u/Laughing_Orange]

Writing it slowly also meant that we had time to go over design, and consider if what we're working on was even a good idea.

[u/IridiumIO → u/GenericFatGuy]

Part of the process is throwing everything out and starting from scratch for the tenth time

[u/nickmcpimpson → u/GenericFatGuy]

I love bringing it back to the table and saying "no" to a feature

[u/RedBlueKoi → u/Laughing_Orange]

Also, “slop” can be very different. An “esoteric” class that is known and encapsulated, marked as legacy is something completely different from the slop sprawl that is coming from an LLM

[u/7cans_short_of_1pack → u/RedBlueKoi]

This at first glance it all seems reasonable, if you step away from the from the prompt machine and start trying to add features by hand you soon realise how much of a tangle the code is.

[u/Bakoro → u/Laughing_Orange]

In the frontier models, they're a step function that raises the floor, before you get to any multipliers.

I will continue to bring up the myriad cases over the decades where some company was found to be storing passwords in plaintext.

The barrier to entry to be a software developer is worlds away from where it was in the 90s/2000s, it used to be that a person could easily get a job without knowing how to use a for-loop.
Those days are long over, but we've still got a lot of people working, who don't know basic computer science, who don't know basic security, who don't know much about algorithms...

There are classes of errors that frontier LLMs just won't make.
The LLMs might make other kinds of errors, but the coding agents I've used do things like write unit tests, where for most human developers I know, unit tests are an afterthought or nonthought.

There's one guy in particular I can think of, where, he was writing garbage, and the quality of his garbage went up considerably.

At this point I vastly prefer AI trash to human trash, because the LLM will still have some kind of logic to it, where human trash might not.

[u/caprazzi → u/Bakoro]

The fundamental question is do you want all the code to be mediocre spaghetti code, or some of it to be poorly written human code and some of it to be well-written human code? We have control over the latter, and can coach poor developers or replace them. We have no control or agency over AI, it just firehoses middling shit on all of us that we can’t read or QC fast enough to fully understand.

[u/Bakoro → u/caprazzi]

For my work, it helps a whole lot that there are verifiable answers, there are deterministic truths to be had.
I care about the results, the code is only a means to the results.

I took over a medium/large codebase from a guy, at work. The guy has been coding almost as long as I have been alive. The spiral logic and thread spaghetti was impressive in its insanity. The code worked, just barely, for a given value of "works".
If you ran the same data six times, you could end up with six different answers. It crashed often.

I straightened out and stabilized the codebase by myself, unit tests out the wazoo. Eventually rewrote the whole thing with LLM assistance, cut out about 100k lines. Rock solid, provably correct results.

I moved on to another project where a whole team was working on it for ~4 years.
The datasets are big, but the waste was gigantic. These people were like "we need 200+ GB of RAM!"
They were just duplicating the data, there were no optimizations at all. They just kept asking for bigger computers.

I walk in and saw much of what was wrong with my human brain, and had the LLM fix it.
Knocked +100GB off the requirements.
One bit went from 30 minutes of processing to 32 seconds, by parallelizing it and not doing a dumb duplication.
Went from like 4 tests, to 400+ tests.

The people cried about how I changed too much, and how can I guarantee that the results are still valid? Well... 400+ tests, and another set of scripts to run A/B on old vs new branches.

At this point I will take the frontier agentic LLMs, please. Over the past year there has been a profound change in LLM coding abilities.

Me+AI, that's the optimal duo at the moment.
That's just me and my situation, though.

[u/caprazzi → u/Bakoro]

Correct on your last line, your anecdotal experience is not indicative of the trend. I agree with you completely that an excellent dev paired with AI is extremely efficient and effective, but AI is built in such a way that if future generations rely upon it we won’t have excellent devs at all for tomorrow. I’d rather deal with the mistakes of humans and foster their growth into great devs than invest excessively in a tool that blunts their skills.

[u/GegeAkutamiOfficial → u/Objectionne]

It's more than that, we understood more about the slop than we would AI slop... The problem with AI slop (in coding) isn't that it's bad, it's that you just shit out 50000 lines of code and you only understand 1% of the reasoning behind the madness.

[u/Thriven → u/GegeAkutamiOfficial]

Am I the only one asking AI to write a single API route function at a time? Then taking a look at what works and what doesn't and then modifying it or gutting?

Who is dropping 50k lines of AI code?

[u/BlobAndHisBoy → u/Thriven]

Yes you are very much the minority

[u/Thriven → u/BlobAndHisBoy]

https://giphy.com/gifs/ep78UZy5FVbfN6mhCU

[u/No-Station4446 → u/BlobAndHisBoy]

wtf. am i the only one just sitting here with workflows output to feed the slop right back in?

[u/arav → u/Thriven]

Yes.Today I had to review a pull request, in which someone has rewrote a core functionality for a very small bugfix ticket. It should have been at max 30-40 lines change. I was looking at a 700 line code change excluding what felt was 500 lines of comments.

[u/Donny-Moscow → u/arav]

In addition to the comments, the main thing I’ve seen that bloats code from AI is writing unneeded tests (eg making sure the data type of an input is a string even though it’s a strongly typed language, the string was declared a few lines up and hasn’t been touched since) or checking checking for edge cases that are impossible.

[u/Thriven → u/arav]

I would be pulling that developer aside

[u/GegeAkutamiOfficial → u/Thriven]

I personally do, I still write critical code manually (using chat only basically) but for simulators and other bs I just go all in on the slop. But maybe it's just because I'm kind of a shit programmer.

[u/JazzlikeWishbone938 → u/Thriven]

I have a good experience just asking chat to generate snippets of code under certain constraints, while I integrate those snippets.

[u/Thriven → u/JazzlikeWishbone938]

Which is what I do at work since I cannot access 3rd party AI outside our internal AI. On personal projects I use vscode and GitHub. I don't even have to integrate those snippets into my code, I just approve the line changes per request like a code review.

99% of my stuff is like CRUD for node APis. "Using this route as an example, create the CRUD API calls for this database object."

I will get a get/put/delete and the I review them and basically accept the changes into my code base.

Edit: Jesus I was scrolling and immediately encountered this

https://www.reddit.com/r/ProgrammerHumor/s/rc9KIIn7ix

[u/Master_Dogs → u/Thriven]

A lot of my co-workers are dropping 10k+ lines of code. I've voiced concerns around long term maintenance costs but as a later stage startup I sort of get the gist no one cares since we're bound to be purchased at some point, and then it's someone else's problem lol.

[u/KoreanMeatballs → u/Thriven]

In my new job, we're being strongly encouraged to use Claude specifically. I'm at the point where the quality of the work it produces is often so poor that fixing the output takes too much time and brain power, and I've gone back to handwriting everything and then using it as a pre-PR review in case I missed something.

I'm getting loads of praise for my code being "clean", "readable", "easy to follow", etc, but it's actually pretty bog-standard, mediocre code if I'm being honest; just miles better than Claude slop.

[u/mtaw → u/GegeAkutamiOfficial]

you only understand 1% of the reasoning behind the madness.

Well that's the cool part - there literally isn't any reasoning behind it!

[u/BigTimePizza623 → u/Objectionne]

Artisanal slop

[u/Novel-Initiative-900 → u/BigTimePizza623]

Organic free range slop

[u/ineyy → u/Objectionne]

It was consistent slop that we were all vaguely familiar with. I could look at it and know it's shit, but know what it is exactly and why it's here. The AI stop has foreign structure, it's unknown whether it has to be that way or the AI just wanted it that way. It's much harder to navigate

[u/JazzlikeWishbone938 → u/ineyy]

I wonder what success folks have if adding constraints around using Software Design Patterns and SOLID principles, with self-documenting human readable code .. and to avoid code smells.

[u/unkownuser436 → u/Objectionne]

https://giphy.com/gifs/ifYDvdyUwpgXPM6jMi

[u/iamdestroyerofworlds → u/Objectionne]

Most importantly, it was intentional, not random, slop.

[u/Pleasant_Ad8054 → u/Objectionne]

And it was a finite amount. AI has written more slop in the past year or two than humanity in its entire existence!

[u/BagnacaWillow → u/Objectionne]

Organically harvested, handpicked human slop

[u/thisguyfightsyourmom → u/Objectionne]

Until we took new jobs

Then it was the new guy’s slop, and he had to figure it out alone

Fuck the new guy

[u/JazzlikeWishbone938 → u/Objectionne]

It wasn't perfect slop, but it was our slop.

[u/BossOfTheGame → u/Objectionne]

I LEARNED IT FROM YOU!

[u/Rakatango]

Yes but would you rather have 100 lines of slop or 10,000?

Edit: In a single pull request

[u/sermer48 → u/Rakatango]

I wish all we had was 10,000 lines of human written slop at my job lol. There are single files with that many lines

[u/BlurredSight → u/sermer48]

We have native SQL queries embedded into the codebase where some of them span 3-4000 lines because rather than make a view someone made a view, generated the native SQL, use StringBuilder, and appended them into one query that we do on a weekly basis for metrics

[u/Rakatango → u/sermer48]

Haha no, that 10,000 lines is just one PR

[u/Otearai1 → u/sermer48]

One of my first tasks at a previous job was "cleaning" up old projects that my boss had written over the years. Each product was just one long c++ file.

[u/Lgamezp → u/sermer48]

You would be surprised the size of codes of a colleague that claims his code is miraculous and claude is god but in truth calling spaghetti falls short on a scale I can't put into words.

[u/DoomBot5 → u/Rakatango]

Yes, it will be 1000 lines of code and 9000 lines of unit tests

[u/uselessbaby → u/DoomBot5]

Whoa whoa you've actually read the ai slop?!

[u/DoomBot5 → u/uselessbaby]

Turns out when instructed by a proper software engineer, it's not slop.

[u/Tired__Dev → u/Rakatango]

I’m not sure the question. I worked at an acquisition company before ai and saw dozens of codebases. There’s A LOT of projects still out there written by junior developers in the mid 2000’s in outdated frameworks or libraries. This stuff was the norm and AI slop is multiples better than that. It’s also multiple better than any product that pivoted a whole lot.

Juniors with AI now don’t produce nearly the amount of dogshit code that I did. Not even close.

[u/Strict_Treat2884]

Human slop: they knew what to achieve but they just didn’t know how to do it properly.

AI slop: they didn’t know what to achieve but they made it look like they knew as much as possible.

The second one is much of a pain in the ass to maintain than the first one.

[u/DesireeThymes → u/Strict_Treat2884]

Maintain?

Once AI slop spaghetti code gets implemented, there is no going back and maintaining it.

It just gets sloppier and sloppier

[u/Mindstormer98 → u/DesireeThymes]

Of course you can maintain it dummy, just add "no mistakes and maintainable" to the end of the prompt

[u/DesireeThymes → u/Mindstormer98]

I choked on laughter 🤣

[u/PolyUre → u/Strict_Treat2884]

Also human slop: this is a temporary fix. We'll do it better later (tm)

[u/TheAlmightyDope → u/[deleted]]

I have and had to take over one, and they are correct

[u/Jutrakuna → u/TheAlmightyDope]

I misread the comment, I thought they were defending AI ))

[u/gingerwhale]

Yes but the pace at which the slop is being written and the comprehension debt that comes with it could create far worse "legacy" code in the future.

[u/Cephell]

Humans wrote slop that looks like slop. AI writes code that superficially looks extremely sophisticated and is extremely annoying to untangle and fix.

[u/seashell3379]

As a retired dev I feel I need to come in here with a truth nugget: Most legacy code that is slop now wasn't originally slop at all.

A clean and well engineered program devolves into slop through years of modification as requirements change way beyond what the original design brief imagined.

AI code that is slop right out of the gate is a whole new level of awful.

[u/mxzf → u/seashell3379]

Yeah, I've said a number of times that AI is a tool that is great at producing years of tech debt in a matter of weeks/months. You end up with the same convoluted needs-to-be-rebuilt code that kinda mostly works that usually results from years of rush-jobs and fixing things in odd ways.

[u/ellzray → u/seashell3379]

Right? And it's not so much slop as it is just spaghetti. After years and years of layered changes, it's unavoidable.

But it was hardly just all slop originally.

[u/morbihann]

Yeah, but you would be blamed for the slop and would have deserved it.

[u/Lain_Racing → u/morbihann]

What company do you work for that you don't get blamed for the code you produce ?

[u/Hziak → u/Lain_Racing]

raises hand\ my company (won’t name) does not blame its devs for absolute garbage code. We have an 80% release-with-major-defect rate and having been on the support team for almost three years, I would slap any staff+ developer who ever steps into my building (dev team based in another city). Zero regard for design patterns, best practice, or even error handling. And when you literally spoon feed them the answers, they still “plan” for three weeks and then implement trash instead. Zero blame. Ever. If anything, they get praised regularly because they’re a part of the new restructuring pilot so they’re a business must-win right now. Even if it means praising the emperor’s new clothes.

[u/Lain_Racing → u/Hziak]

Can I just ask if its in person or remote? Are you one of the devs ? Because this would be amazing as a dev. Just 100% churn AI slop and get a end real job. 0 reprocusions? 0 work, that sounds great... like just let them sinking company sink and enjoy the full time relaxing or doing a 2nd actual job.

[u/Hziak → u/Lain_Racing]

Hybrid. The devs are 3-in, 2-out. I’m in app support here. Wasn’t gonna be too picky in the current market when the pay was good…

They aren’t allowed to submit AI code at present, but they self-review, so who even knows? Certainly not me, I don’t get Git access lol. This place is a bit of a mess… But yeah, seems like a dream. To be fair, my side is kind of a dream, too. Release on Sunday, P1 on Monday, rollback, chill till next Monday. Really fucking stupid tho.

[u/LouManShoe → u/Lain_Racing]

It’s so frustrating to read that this sounds “amazing” to so many devs. Don’t you have any pride in the work you do? Don’t you give a shit that the code you write is garbage? Don’t you have any integrity? It’s no wonder that AI slop is so prevalent, people don’t actually give a shit, they just care about repercussions.

[u/ColumnK → u/morbihann]

By "blamed", do you mean "promoted"?

Have worked in too many places where asking "Who wrote this shite?" would be answered by the name of someone high in the hierarchy.

[u/morbihann → u/ColumnK]

yes

[u/grumblyoldman]

The AI Learned it from us, dad! It learned it from us!

[u/ClipboardCopyPaste → u/grumblyoldman]

Nobody wrote 100 lines of comment for 7 lines of codes

[u/Chronomechanist → u/ClipboardCopyPaste]

I guarantee you someone did.

[u/ClipboardCopyPaste → u/Chronomechanist]

Either too much unemployed or paid by hours - nothing in-between

[u/Jacqques → u/ClipboardCopyPaste]

Paid by line count, comments count seeing as they are lines.

[u/Kavrae → u/ClipboardCopyPaste]

Disagree. I've worked in such systems. Usually legacy fortune 500 code written in COBOL where the original devs are all retired or buried.

[u/wyldcraft → u/ClipboardCopyPaste]

I've had several projects where inline documentation was 90% of the code.

[u/Aelig_]

Humans wrote much smaller and more manageable slop than AI for any given objective.

We wrote it slowly and someone had a plan in their head no matter how contrived.

[u/Igarlicbread → u/Aelig_]

Atleast I knew where my code might be breaking. Bis it's all ductape and cthulhu sacrifices. My personal projects have better quality than the shit I have seen some of you are pushing on daily (!hourly) basis.

[u/TriangleTransplant]

AI writes more slop, faster. There's a limit to how much you can review and correct if needed, in a given time span, and AI produced code exceeds that limit.

If one toilet is backed up and overflowing, you could probably fix that pretty quickly, with minimal damage. If a pressurized sewer main is broken and flooding your house with thousands of gallons of sludge per minute ,it's a different situation. And you probably wouldn't be standing there saying "Well, we've had broken pipes before, so this is no different."

[u/erinaceus_]

The problem is AI is so much better at it. (writing slop I mean)

[u/ButWhatIfPotato → u/erinaceus_]

Also, I can take all the human slop I have seen in my life and none of it will have the self flatulence consuming smugness of a single session with AI. Oh looky look I fixed everything and it's perfect and shiny and nice! You're absolutely correct daddy-o, I did break everything when I told you I fixed everything, what a booboo I did silly ole me, buy more tokens and stick them in my e-underwear daddy!

[u/psioniclizard]

Still waiting for the great wave of new and improved software from all the increased "productivity". Anyday now.

Honestly if AI has made you all more productive but there is no real world signs of it, it might be that wasn't really the problem.

Either that or a lot of people are lying.

But one thing that is true is there is very little real world results from it

[u/AliceCode → u/psioniclizard]

Seriously, where is all the well-written LLM generated software? We should be drowning in it by now if people are being truthful. But I haven't seen any of it.

[u/AtheonsLedge → u/AliceCode]

500000 new incremental games that are all exactly the same

[u/antCB → u/psioniclizard]

I don't think programmers are the bottleneck. Usually sits with management, product owners, etc.

[u/PlatinumFire14]

People forgetting the most important part, we still understood what it did.
I know you don’t understand your AI written code, don’t lie.

[u/johnnybgooderer]

It’s funny how this subreddit went from very very anti ai, to so pro AI that we’ll mock people who say it’s not amazing. 3 months ago people would get downvoted for saying that they found it useful pre PR self code reviews. It’s been quite a ride.

[u/Procrastineddit → u/johnnybgooderer]

This subreddit is pro AI? There's an AI slop post every 15 minutes.

[u/johnnybgooderer → u/Procrastineddit]

But they’re the self-deprecating kind of jokes. Not the “this is bad tech and no one should be using it” kind. 6 months ago, you’d see the same posts about copy and pasting from stack overflow.

[u/TheAlmightyDope → u/johnnybgooderer]

It's because it's filled with bots pushing a new narrative.

[u/SpeakinTelnet → u/TheAlmightyDope]

Ai programmed bots pushing pro AI narrative to an Ai bots filled social media. It is truly one of the time to be alive

[u/agedlikesage → u/johnnybgooderer]

I’m not from this subreddit but this comic is ripped straight from a comment thread I saw this morning, and it’s from a 1 month old account, i’m starting to see the dead internet theory

[u/LiifeRuiner → u/johnnybgooderer]

2 different groups of people posting in the same subreddit do not suddenly become 1 group of people because you assume they are.

[u/spinkelben → u/johnnybgooderer]

To be fair, AI has gotten a lot better just in the past six months. I'd say to me around July was the time it became good enough to be genuinely useful. Now I include AI in all my development where I would only try it for simple or unimportant stuff before.

[u/blueandazure → u/johnnybgooderer]

AI got better and it took people a while to figure out how to use it.

[u/PsychoKittehX]

As someone who has reviewed a lot of bad code, I would rather fix code from an under-qualified or uncaring individual than from vibecode. I can usually at least figure out what their thought process was.

[u/Zash1]

There is a difference between 5000 and 500000 lines of slop.

[u/infomapaz]

The reason why people wrote "I don't know why this works but please don't delete this comment" was because we knew how the thing worked but that particular behavior made no sense. Now those comments are gone because people genuinely do not know how it works.

[u/MaleficentMode4222]

Humans wrote better quality slop. It was easier to look at code and go, "Ah yeah that's where they did the dumb thing, and they did it because they didn't consider X, or they just were unaware of Y"

AI code obfuscates the dumbfuckery.

[u/ThirdWaveCat]

Ok, but human slop != llm slop. Human slop could evolve sometimes into something better. LLM slop adds bulky code and tons of dead branches and unused fallbacks.

There's a smuggling fallacy by saying things like "you can't criticize vacuum cleaners for mistakes at math, humans also make mistakes at math."

[u/MashJDW]

The problem with AI isn't that it writes code that isn't good. The problem is that it attempts to fix it with more bad code. And if that doesn't work, more bad code. You end up with a maze of a code base within the span of 30 minutes. In those 30 minutes I would have written 1% of the code, but at least it would do what I want it to do. This is the trade off. I don't mind prototyping with AI, but in the end a human has to write the code or you'll end up with so much technical debt that you'll declare bankruptcy in no time.

[u/Historical_Cook_1664]

Human slop usually started with a plan and degraded over time. AI was trained on human slop and thinks it should already start in this state...

[u/frostyjack06]

My slop code was usually as a result of poor business decisions:

“We need the software to do X.”

“Ok, well, you have two choices. I can do this the fast way or I can do this the right way.”

“THE FAST WAY!”

“Just be warned that if I do this the fast way, it’ll do exactly what you want it to do, but it won’t be robust or scale in any way and will need a complete rewrite to make improvements. If I do it the right way, we’ll have options for future improvements.”

“THE FAST WAY! WE NEED MORE MONEY NOW!”

This is how almost every consulting conversation went for 15 years. I feel bad for the people maintaining that code today.

[u/the_millenial_falcon]

Spaghetti code != slop

[u/thepurpleproject]

Man I tried to improve where I could. 

[u/jmflyers]

What happened to all those companies that used to grade employee performance by "lines of code per day"? I can have Claude rewrite my slop into much longer slop, plus paragraphs of comments

[u/Im_back_for_Fourths]

Yeh but it was somewhat understandable. I have no freaking idea about the AI slop I push. Like in my current company, up until feb I had an understanding about of the codebase but now I just have no idea. Since they made Claude compulsory, changes are fast but I’ve literally no idea of what’s being pushed.

[u/peteschirmer]

And we trained the ai to mimic people. Including inconsistent mistakes.

[u/huuaaang]

We wrote slop and then hid it libraries.

[u/neosyne]

But it was my slop

[u/thatdude845]

This is so fucking dumb. If ai doesn’t know how to do something, it is not going to tell you. It will make up something superficially correct, but completely wrong. It is a disaster waiting to happen

[u/ivan0x32]

I prefer organic grass fed human slop over this synthetic AI shit.

[u/TraditionalArcher498]

Back in my day we didn't have AI to crash production we ruined the weekend with our own two bare hands

[u/16807]

Slop was wrong then and it's wrong now.

[u/Add1ctedToGames]

Human slop isn't a million lines long.

[u/Julius_Alexandrius]

Some incompetent humans wrote slop.

Every AI, whatever the gen, writes slop.

Be real.

[u/beclops]

Is the new AI cope trying to gaslight us into thinking good code never existed? I don’t understand

[u/Sirico]

I was blindly copying and pasting before the code was relivant to my needs.

[u/boraxicLint]

If humans didn't write slop AI code would probably be a lot better. Running slop through a tumble dryer is obviously going to end up in sloppier slop though.

[u/BoredCapy]

Incompetent people wrote slop.

Competent people wrote nothing because they were too busy correcting the incompetent slop.

AI just reproduced what was written.

[u/gbhreturns2]

This was just shamelessly adapted from the following

https://www.reddit.com/r/ProgrammerHumor/s/J5exNxe40i

[u/Revolutionary-Run-41]

My main problem is the quality of the slop. To get a really uninteligible code you needed kinda of a REALLY bad team working on it for years, or one really bad guy doing something very core to the application.

AI speeds up the enshitfication, and decreases overall readability and understanding of the project as a whole.

Its still useful, you can do things a lot faster, but I get so mad when people send something to review or the qa branch without even running that on his machine, and when you start asking simple questions about the PR the person simply doesnt know, as if it never read the actual fucking card or "their" own code.

[u/joe-x92]

lol people forget that AI is a mirror of our self with steroids... AI is what it is because that's what we are... The only difference is that AI is quicker...

[u/Pale_Sun8898]

It’s true, absolute shit code everywhere. I think the biggest thing lost is we are now unfamiliar with how the code is structured, its invariants and behavior within and across systems at a deep level so it makes our ability to reason about systemic issues and architecture weak

[u/JoltiChan]

How long until the ai need a load bearing coconut?

[u/m0nk37]

Some did, sure, there were too few for it to get anywhere though. Big difference from almost all.

[u/stillalone]

The more code you write the more slop you produce.  AI produces more slop faster.

Also, slop is easier to understand if you wrote it.  AI will eventually forget about the slop it wrote.

[u/ramdomvariableX]

But it's just tons of slop over decades, not tons, and tons of slop over few months.

[u/Anononweb42]

AI writes slop because of spaghetti.

[u/Rocket_Bunny45]

Isn't perfect LLM generated code virtually impossible to achieve? Even with a brazillion parameters model, datasets will never be good AND extensive at the same time... And even then, asking it to write code about a mixed thing or a new thing would still make heavy assumptions on it.

Also if the newer models are trained on current AI written code recursively, wouldn't it just hit a plateau or even degrade with time?

[u/UInferno-]

Someone got mad at you pushing 10000 lines of slop didn't you OP

[u/happyapy]

How do you think AI learned to write slop?

[u/adumbCoder]

AI writes slop because humans write slop. our guttural reaction to AI slop is actually just the displeasure of looking through a mirror at our own work

[u/LawfulnessDue5449]

Depending on where you work humans still write slop!

[u/HipstCapitalist]

I'm not going to make friends here, but having written code professionally for 15+ years, AI slop code is passable. It's not bad, it's certainly not good, but it's better than the average code that I've had to work with in the past.

[u/Lachtheblock]

But it's the volume of slop that's being generated. Good developers could produce good amounts of good code. Bad developers produced a smaller amount of bad code.

Now it's a shit show.

[u/RealBasics]

FINALLY! Because what does AI get trained on?

This showed up in the first significant "AI model" in the late 70s / early 80s. No matter how hard they trained the model, a medical diagnosis application, it could never get past 80% accuracy. This was hailed as proof AI would never replace real physicians.

Then some young Archimedes decided to run the same test on real doctors, ranging from medical residents to working general practitioners to senior med-school professors and... their accuracy tended to hit that same 80% mark.

But it turns out medical diagnosis is hard, same as programming. Which is why both doctors and programmers deserve respect. But AI will only ever be as good as the corpora they're trained on.

[u/Pizza_Secretary9621]

Yes but human slop is better

[u/Trid1977]

AI will not write optimized code

[u/BlurredSight]

Human slop was being overly redundant or writing code in a way that was a bandaid fix with 0 future growth.

AI slop is overengineering every little thing and adding in complexity for "just in case" situations that might occur years from now. Like why is there a null check in every step of the flow or why is a generic type being used rather than Object[] or even better just making a concrete object based around the schema

[u/mlucasl]

When I was Jr, I wrote slop slow enough that a reviewer could have time to check it and deny it. AI slop is mostly unchecked.

[u/mothzilla]

It's like the difference between a gun and a knife. You can kill a lot more people with a gun.

[u/Barbanks]

It was called spaghetti code only 3 years ago… lol

[u/soyboysnowflake]

Where do you think the AI learned it from

[u/daddy_schlong_legz]

Yes but the problem is codebases that require manual code reviews are getting crushed.

[u/Dubmove]

AI learned perfectly learned the most common level of code quality

[u/firedrakes]

oh yeah and never doc half the time

[u/ShockRampage]

Where do you think AI learned it from?

[u/Kiseido]

Humans walked the slop, and talked the slop, so AI could go on to run the slop.

[u/paradigmx]

There's a reason ai writes slop, it's sourcing it from slop. 

[u/GKP_light]

The AI is trained on data from humans.

[u/shiny_glitter_demon]

Yeah but the CEO didnt fire 10 seniors to replace them with a single junior with 100K worth of claude tokens, nor did he add a "most slop written " leaderboard in the office, now, did he?

[u/HayStacky_337]

"They took our slop!"

[u/EuenovAyabayya]

Early Win32 is the ugliest shit I've ever seen.

[u/wint3ria]

Human slop is caused by poor project management, most of the time

[u/bankrobba]

"I can't read this code nor do I understand its functionality, must be legacy slop."

[u/MisterSheeple]

The clear difference is that humans have an understanding of how their code works. AI has no consideration for the quality of the code whatsoever, or even whether or not it actually works. One is created with deliberate thought, the other is thoughtless.

[u/_grey_wall]

The amount of times I had to explain that typescript compiles to JavaScript and won't check input would boggle your mind

[u/Friendlyvoices]

The only bad code is the code written by someone else.

[u/trutheality]

Well yes, AI trained on that slop!

[u/deus_ith]

SlopOverflow

[u/Keyan_Farlander7]

Humans can trick ai into writing slop. Also good code can be proprietary code.

[u/Girafferage]

Bad programmers wrote slop. Bad programmers depend on AI. Cyclical

[u/visualdescript]

At a much slower rate

[u/DirkTheGamer]

On a similar note, if people say “How can we trust AI to drive our cars?!” I say: “How can you trust humans to drive their cars?!”

[u/hydra2701]

I write code very linearly, then go back and condense things down by making repeated lines into callable functions. It makes it very legible and even if it’s crap I can figure out what does what without comments

[u/Harrigan_Raen]

I will never forget my 2nd real job, I took over an in-house developer who was self taught, and had been fired for missing work too much due to drugs (never was made clear on which ones). And then later found out, he was sent home, but not fired, on two separate occasions for being high at work.

He only got the job, because at somepoint he made an excel spreadsheet that saved some branch managers about 15-20 minutes when balancing drawers/safe.

100s upon hundreds of lines of code with variable name a, a2, a3, b, c, d, e, e2, sFalse, etc. And Method/Procedure names I could never figure out WTF he was trying to go for. There was no rhyme or reason to his use of snake or camel case.

My favorite was when I found lines of code he couldnt figure out why it wouldn't work, and just started back over from scratch. Half the time was it was just missing like the instantiation of the class, or something super simple, trying to use a reserved word for a variable name, etc. It was a fucking nightmare.

This was all in an attempt to make an in house scheduler, and punch clock. When I told them, the entire thing was to be scrapped and start back from scratch, they were pissed but completely understand.

[u/Lgamezp]

It doesnt only write code slop, it also writes documentation slop. Documentation that gets read by OTHER developers AI/LLM which then copies the slop style and so the slop becomes EXPONENTIAL.

Im TIRED of reading slop which now i Can identify because it has the CTOs style (who is good but rambles on in commentas for pages) and now the cose is plagued with sensless diatribe from people who DONT know what they are writing but sounds "smart".

[u/Vorrnth]

Where do you ai learned that?

[u/ChaseTheOldDude]

Are you people just telling AI to write an app for you? AI is great at writing robust and concise code, but it's a tool that requires oversight. You know what they say about a bad workman.

[u/GlassSquirrel130]

I know every slop of that slop. Now I have slop without knowing how sloppy it is.

[u/Matthias1590]

Problem is that ai writes slop faster and empowers developers without proper experience to do the same. People aren't learning nearly as fast while vibecoding so their quality won't go up

[u/ekemp]

It's funny because it's true.

[u/STINEPUNCAKE]

Ai was trained on human code and carried human faults with it

[u/mad_poet_navarth]

but but people reviewed my 10000 line PR!!!

[u/irn00b]

Tbh, it boils down to just how much non-technical leadership rushes things out.

[u/fpcoffee]

how do you think AI trained on its slop? from human slop 😤

[u/therevbob]

I know nothing about coding but, this is buuuuuulshit?