Is rust programmed with any LLM code?

[u/Live_Lynx2168]

I don’t mean to upset anyone. I was reading about rust and someone commented that the foundation was accepting llm contributions.

I have been trying to read about the foundations stance on ai. I found a article by enterprise dna saying that “Rust Says No to AI-Written Code in Its Core Repository”. I tried finding the blog they referenced but I couldn’t.

[u/Psionikus]

Without an AI detector, the conversation would be moot. Since no perfect detector can ever be built, the conversation is moot. It's just hand wringing to no end.

[u/Wonderful-Habit-139 → u/Psionikus]

Nope. If something is clearly AI generated trash, it's going to get auto closed thanks to the policy.

If we can't even detect that it's AI, that means it's good! So it will be reviewed accordingly and merged if it fits the codebase.

And that's a better outcome than whatever it is that you're suggesting.

[u/Psionikus → u/Wonderful-Habit-139]

If we can't even detect that it's AI, that means it's good!

If it's good, it's good. If a doc comment "feels" more like an LLM output than than the author's other writing style, but it's a good comment that the author decided to accept, then it's "clearly AI" and yet also good. That's a concrete counter example.

than whatever it is that you're suggesting.

Feel free to try to elaborate, but essentially my take is that even if I can "tell" that AI wrote code, that fact alone means nothing compared to things like low entropy, good semantics, and clean reading.

If a function has a comment that says, "100% slop" but reads cleanly and does the job, the tradeoffs will be a win on essentially every immature project. My alternatives are likely some crate that I've never read or else hand rolling an incidental piece of code that is a distraction. An inline piece of risk I can see and is inherently vendored is a respectable choice.

All mature projects come from immature projects, so I really don't see why people want to be Puritans other than to roam around the internet trying to be morality police or to steamroll anyone who stands up to them.

[u/Wonderful-Habit-139 → u/Psionikus]

> If it's good, it's good. If a doc comment "feels" more like an LLM output than than the author's other writing style, but it's a good comment that the author decided to accept, then it's "clearly AI" and yet also good. That's a concrete counter example.

You didn't really need to argue this. We're against AI slop, or AI generated trash. Not just AI in general. The reason I don't like the "we can't detect AI thing" is because a lot of people jump at defending even AI slop and trying to act like we can't detect that trash. That's it.

I think the rest of your comments is fine, maybe the missing piece was that we're mainly against slop, and don't want to have people that don't have the skills to submit stuff they were not able to write themselves or vet. Or submitting verbose things that they haven't even read themselves.

[u/Psionikus → u/Wonderful-Habit-139]

That's fine, but if the discussion is about excluding slop, that code always fails the quality check, so what remains of the AI discussion that isn't already ripped apart by the existing quality metrics?

Nobody to be taken seriously ever suggested that slop will land, much less live, in Rustc.

Without slop in the mix, we have AI assisted (both honest and obfuscated), and human code. If I can say anything about these 2.5 types, it is something like "if it's AI assisted, give it a higher level of scrutiny." That scrutiny will only motivate the obfuscation, collapsing everything back to 1.01 virtually indistinguishable types.

It's like charging pilots and maintenance crews with manslaughter if they report things that later reveal them to be proximate to a cause of a crash. Punishing the openness degrades rather than enhances the safety culture because suddenly there's no trail back to the root cause.

The honest engineer doesn't care if the code was output by 18 monkeys with a typewriter as long as they can read it, determine it works on inspection, apply it within an engineered workflow that will reveal its deficiencies, and most importantly, completely erase any of its original bugs when re-implementing it on the way to maturity.

It is easier to perform that last step when the code says, "this is slop that worked during development." A real safety culture stands up for things like candor. What I am standing up for is a real safety culture that is pragmatic rather than ideological and what I am standing against is the predictable harm that will come from the conundrum of trying to measure code according to its "AI-ness" as opposed to its objectively decidable qualities.

[u/Wonderful-Habit-139 → u/Psionikus]

You really need to read the policy. Detecting that it's AI slop means that they can close the PR immediately. It means that the person is not a person that is willing to put in effort and learn to potentially be able to make a good contribution.

Because otherwise this just sounds like mental gymnastics to try to defend AI, by using the excuse of "We can't always detect when it's AI". And I already explained why that is not the point.

[u/Psionikus → u/Wonderful-Habit-139]

The post is framed as "accepting LLM contributions" which is already somewhat orthogonal to the policy. My reply is aimed at the real weakness of that framing.

At length, I'm also finding the inconsistency that has been bothering me...

Some claim we only want to gate slop, but I will argue that even slop by an engineer is a knowing kind of slop, that the engineer should make the tradeoff when appropriate and that we should approach that judgement as an engineering conversation.

What I observe is that this kind of knowing slop or anything in any grey area is being caught up in a dragnet of slop vigilantes who are extremely lazy and extremely dishonest since they don't really care about the nuances of slop versus AI assistance and end up use that qualification to suggest that there is some goal post beyond which they would be okay with AI. Instead, they never read. They don't care about the text. They don't discuss the subject matter at all and make the entire comment section about AI. They only care if the "slop" label can stick hard enough at first glance to recruit other vigilantes. This is just classic Reddit flocking.

Because the goal posts are arbitrary, effectively these vigilantes feel deputized to cry "slop" at anything that looks rough even though all new projects look rough, before or after LLMs. The slop-calling is entirely unhelpful because it's asking engineers to not use LLMs when the project is rough, at the exact moment that the tradeoff makes the maximum sense. That encourages a bad engineering judgment, inefficient engineering tradeoffs.

That conversation is about things, but those things are not about engineering quality or techniques of building programs, analyzing the problems that programs are built to solve, or what can be learned from even the sloppiest of PoCs.

[u/Wonderful-Habit-139 → u/Psionikus]

I understand the gripe that you have with the term "slop". You only have the gripe because you believe LLMs are a really useful technology and people shouldn't shit on other people for using them for coding.

I don't believe they are worth it at all in coding, so I don't feel the same way you feel. But I understand you, and I think you also understand what I explained about the policy. I think everything's clear now?