I’m still sad that Debian is now integrating (external?) LLM in the build process which seems antithetical to the core values of Debian (as pointed out).
There is no alternative to Debian for me. I’m ready to justy throw out all my computers and become a goat herder at this point.
PS I’ll remove memory and storage from said computers to pay for land and goats before I chuck them out of my window.
I don't think there's another way. Everybody is being spammed with Gen AI outputs and the only even to it seems like a paradox way to fight it is with LLMs of some kind or go around it like what the EU is trying to do with watermarking and then detect AI and have different processing for it. I kinda think we could end up there, but we are still not there.
> spend my valuable developer time (this is my free time)...
Lesson for us all is that if we do not own the thing/project/etc, things can suddenly change without our decision, and all time we put into it might become a waste-of-effort retroactively
don't let it stop you, but don't conflate open source with open core or 'democratic governance' etc.
Open source is open source. publishing code.
it does not mean
- you need to respond to peoples PRS
- it does not mean you need a github
- it does not mean you need to provide ANYTHING to the user. No warranty.
- you do not need a mailing list
- you do not need governance
Do what you want, have fun, if you have peers or other people interested in your area, feel free to collaborate in the same way you would with pickup basketball at the park, play, have fun, and leave when you're done.
Yeah AI is the relevant stand in but ultimately this is about one group of people being lazy and trying to shift more work onto another group of people. It just so happens that they are using AI to do it
You can disagree with their approach, but I don't think it's fair to call the DFSG team, which is comprised of unpaid volunteers, "lazy". They have to vet every brand-new package that enters Debian, and their queue has an infamous history of being a bottleneck in the Debian project. Their time is certainly more valuable than the the time of the individuals uploading new packages.
I understand your confusion, but here's the truth of the matter: None of this has to be done. If anyone on the DFSG team does not want to do this work the answer is simple: Just don't do it.
I guess I have to temper my own statement a bit. I do see situations where I would generate and send automated LLM messages. Probably to reply to generated unsolicited messages or pull-requests.
But to upload to debian new's queue you already need to have pre-approval, it's a different situation from e.g. a public git repository that anyone can push to.
To help classify between human and llm-generated ones? I don't know, and you're probably right than in this case a fixed message would be better.
Another situation where I would use llms to generate messages is if we've mutually agreed to do that. For example automated review messages at work, if we've agreed that it would be a part of our workflow.
A good rule of thumb might be unsolicited vs solicited llm messages.
Ok, for unattended replies indeed a fixed message is much better; you can't predict what an LLM will output, and a certain impersonal message is better than a personalized one that might be completely senseless.
And even with a mutual agreement - default LLM output tends to be very hard and inefficient to read. We've spent quite a bit of time at work to setup a few writing skills for Claude.
For example, mine is a technical writing skill based on the old book "The Art of Scientific Writing": Front load information as much as possible - the first paragraph of a document should be a summary, the first sentence of a paragraph should summarize. Short sentences building on each other. Always show evidence.
Someone else spent quite a while optimizing a standardized PR description template, with a section for intent, expected changes, risk, rollout coordination and such.
But there is also way to throttle that. Have AI go thru submission guidelines, compare it to PR and have it shut up when most (not all! AI will always give a reason if you ask it to check something) of it is correct, and only answer when the PR itself doesn't comply to the project rules
It's disingenuous to compare LLM outputs to script generated ones. They have more differences than similarities.
A script is reproducible, and fixable. They won't waste your time hallucinating issues. Note that this is different from "being wrong". A script can be wrong, and you can spend time debugging it, but that time is not wasted. You can fix the script, remove wrong rules, whatever.
Also, nothing exists in a vacuum. Script-generated review comments were never a widespread societal issue, LLMs unfeterred content generation is.
It's a bit insane how it seems that "deterministic and reproducible", what I would consider to be a cornerstone of good software development, has apparently become an afterthought in the age of LLMs. All that for the sake of perceived convenience.
Not even convenience at times, I think that for some the amount of technical-sounding text LLMs can output on demand is comforting. It feels serious. It feels like it's doing something important.
Meanwhile the rest of us have to deal with these low-signal/high-noise walls of text in commit messages and PR comments. Or ask another LLM to summarize them, I suppose. "Doing and undoing, it's all work", as we say in French.
Devil's advocating here... is human code deterministic and reproducible? If I am assigned some non-trivial task, and write it twice with a week in-between, the code is not going to be identical, though it will meet the requirements. Or, if you give 3 different senior devs the same task on the same day, they will all be different, but still meet the requirements. What is different about asking an LLM to write code?
Well, for one thing, a human actually understands what he's doing. He isn't just generating something plausible based on statistics. As a result he makes fewer mistakes, can catch his own mistakes, and can learn from those mistakes.
Is the hallucination or “being wrong” the only major problem? Because if that’s the case I can’t imagine that problem will still be around in ~1-5 years.
I think it’s actually very similar to a script. It takes an input and produces an output.
> I'm not anti-ai but I am firmly anti-make-people-read-llm-output-I-didn't-read-myself, and this breaks this.
This here might hit the nail on the head exactly in terms of what the biggest FOSSes gripe with LLMs with might be: not the fact people use it but rather how it hinders the communication.
If you use it to help the write code, but you explain things in your own words or, at very least, redact and trim LLMs output, it's fine.
If you, however, just drop a wall of text at someone and expect they act on its b/s, this is lazy to the point it borders with microagression.
You wouldn't expect a distinguished professor explain basic maths to a student, and we shouldn't expect actual developers address Copilot's stupid, unredacted hallucinations or otherwise unrelated remarks.
This works for patches submission, too: you should be outright banned for submitting stuff you didn't bother to double check and properly document.
That is one of the biggest gripes for almost anyone I ever met who deals with AI generated content. Nobody really cares that someone else's work was generated with AI as much as they care that it's slop and they need to put in extra effort to work around the author's laziness.
Lazy or incompetent colleagues always forced people around them to overcompensate and correct. AI increased their firepower and blast radius.
This is what we as consumers should look out for; what the tools built on top of LLMs try to do. Like it's neat that a tool can summon a dozen subagents with various models to churn out tasks, but if the task at hand is trivial then the amount of tokens used for it should be trivial.
We'll see the tools get adjusted over time to use more and more tokens, or at the very least they get optimized to use every paying customer's tokens for whatever period so that they are on the one side thinking they're getting their money's worth, or on the other that they should upgrade to a higher tier plan. Because the companies are investing trillions into thousands of datacenters and if they sit unused it'd have been a waste of money.
(the datacenters won't go unused I'm sure; any unused capacity will end up on a spot market, with cryptocurrency generation as a constant baseline. I'm pretty confident that crypto will make another small resurgence after the AI / datacenter investment bubble pops. This is a random internet comment, not financial advice)
If you could explain what you're doing why would you use LLMs to do it in the fist place? For speed over control? Explaining means you're effectively able to do the modification yourself, and I'm fairly certain that's a low percentage of all AI contributions.
No, most AI users who contributor to OS do not actually know what they're doing. Its a problem. And no amount of analogies about house keepers will change that.
That's the problem. We have a bunch of people who know how to do the work arguing about using LLMs to do it and assuming that all the submissions/reviews/etc are being done by people like them who know how to do the work.
Once you're drinking from the firehose you realize just how many idiots (well meaning or not) are out there, and how empowered they are now.
Maybe we should all respond to LLM text walls with aggressively doubled LLM text walls, expanding geometrically until the originating party either gives up or learns to communicate with their own words.
This is the short-term singularity, LLM agents endlessly conversing with another, just churning through tokens to throw noise at each other until it becomes a big ball of LLM turbolanguage.
Either some consensus emerges or it just deadlocks in place. My money is on the latter. I wish my money was in the companies profiting on it three years ago because that's the only way this will financially benefit people.
> They also have a reward system that punishes people for ignoring the llm review (by pushing their submission lower in the queue).
This is what I fear will push its way into every part of society soon, too.
"We're not forcing you to do your banking through our AI interface instead of a normal one, you're free to opt out, but multiple functions will be missing and we'll charge you a monthly fee."
"You don't have to have an LLM grade your exam, but beware that the human grader will be overworked and grumpy for the extra task."
If you’ve applied to jobs recently, you must have seen the companies that transcribe and summarize interviews using AI (and probably share data across their clients in an indirect, technically legal way).
You can opt out, of course, but do you really want to be the one candidate for which the interviewer needs to take notes manually? And they just spent a lot of money on this hiring AI tool, will they hire the one candidate for which they couldn’t use it?
So I've heard. I also know that several doctor's offices here use AI transcription. I'm sure I have a legal right to demand that they be switched off (I'm worried about privacy and accuracy here), but then I've got to be an asshole and increase the workload on my well-meaning doctor who probably had no say in any of this.
This is gonna get so much worse. It's like the smartphone revolution on steroids – and we've seemingly learned nothing! We're in dire straits.
I went through a lot of medical stuff a few months ago, and every single doctor asked me if they could use the device for that instead of typing it into the computer themselves. One of them explained that it allowed them to focus their whole attention on me, instead of partially on the computer for the inputting of the data while we talked.
I'm surprised that your doctors weren't asking, and instead were just assuming.
I don't believe they merely assume. If they don't ask in person, you've probably already opted in through patient check-in forms or the UI of a telehealth app.
That's cute. Yo, people be having full on AI-led interviews! That is to say, there's the human interviewee, and an AI, testing the human. Asking them questions and having a conversation that is definitely recorded.
Compiler output is somewhat deterministic and there is a logical path (even if caused by a compiler bug) and not dealing with it will definitely(!) lead to a broken product. Also at least I rarely read the full output, but I have an intuition, as the structure is consistent, what to look for in the output.
LLM output may or may not be relevant, may or may not tell me something new and by the way it is structure is often hard to quickly oarse for the relevant piece in a wall of text.
Maybe it's an unpopular opinion, but a concise report from one of today's frontier models is not something I would be offended by, even if nobody read it beforehand. I guess the fact that there is a nontrivial cost to it also eases the existential angst of neither being deterministic (Lintian) nor having been produced by a person.
Disclosure: I'm not a Debian Developer, yet I have worked on Debian derivatives and I'm somewhat familiar with internals of Debian from technical and human perspectives.
While I'm perfectly on the same page with the critics of the LLM generated summaries, I'm a bit torn on the issue.
For anyone not familiar with Debian ecosystem, there's a helper tool called Lintian. Lintian does all kinds of checks from package formatting, licenses to dependency management (which can detect both unnecessary yet included and necessary but missing dependencies via static analysis of your tool if necessary).
It's expected that your package to be "Lintian clean" to be able to included in Debian with minimum friction and wait. Even though it's Lintian clean, your package also checked by teams which are severely understaffed, and composed solely of voluntary people.
NEW queue also receives tremendous influx of packages (which can be considered a torrent, even). Since noon, there are 10 more ITP (intention to package) bugs open in my inbox.
As a result, at one hand, these people need every help they can get because getting new trainees and getting them to learn the intricacies is hard, on the other hand LLM generated text rightfully generate negative reactions from people. However, giving developers an automated check of what looks right and what looks wrong is helpful, in my perspective.
I wonder what people would have said it was a deterministic tool generating these reports and sending people these summaries as a "hey consider this feedback until a human has time to see your package".
This is a hard question and we need to think before impulsive reactions. I even don't have all or any of the answers, but at least I have some insight why this is there.
This is a strongly phrased message but the problem could be solved with an opt-out.
Even something as simple as writing the phrase "No LLMs please" somewhere in the upload, that if present, prevents LLMs being triggered. Nothing elaborate and it preserves the default-on behavior the team seems to want.
Yes, the point of the article is that he'll stop uploading _unless_ there's an opt out.
> I will not upload anything to NEW unless there is a way for me to opt out of
this. I would prefer if the default was "no LLM review" and that developers
have to explicitly opt-in to receive an auto-generated review.
i wozld not care for most other actors even in the FOSS universe to swallow their pride and put LLM into their workflows.
However, Debian proved in countless occasions before that they can and will go the route that is right, not the one that is easy, even if it makes everything slow or cumbersome and I think thats a good thing and the reason why so many others build their stuff in top of it.
I think this the wrong question to ask. The original complaint suggests that llm setup used is largely unknown in terms of how it organized. For all you know, it may be splitting and sending different requests to unpaid gemini, local 8b qwen or paid claude/astra. None of it is known, listed or noted as expected to be somewhat stable.
The question is not even about the setup in terms of hardware/software. The question is about organizational structuring of its processes.
* Picking at random a successful and unsuccessful LLM-generated
review from the dashboard, the successful review consists of 734 words
(~2.5 printed pages) and the unsuccessful review weighs in at a
whopping 1,535 words (~5 printed pages). I haven't tried to fully read
either report, nor spend brain cycles checking if the LLM output is
legitimate or not. I just want to emphasize the many orders of
magnitude change in review size that's being generated, and that
uploaders may need to spend time trying to review and understand in
this new process.*
A bit rude to expect people to swallow 5 pages of slop to figure out why review failed.
>>Any distro that have adopted a hard anti-AI stance?
Yes all the BSD's, and i think with the best explanation, since one cannot proof what license the llm's output has, one cannot legally implement the output under the BSD-License.
But what about Linux? They just dont care, they have the money, corporate backing and with that, all the power.
Unfortunately, as we can see here isn't not just the corporate projects that are susceptible to people ignoring morals in the name of pRoDuCtIvIty. It's really sad to see Debian of all distros, who where one of the major sources of what it means for software to be free, to go down this road and so quickly.
I’d rather have a detailed explanation of why my contributions are being rejected rather than the complete opposite which is often something along the lines of “no”
I think some developers are kinda dense or something, and don't understand that shoving AI content in people's faces is simply rude.
In recent versions of iTerm2 for example, when using the plain old menubar and hovering over some items, panels appear showing awful sloppy AI images. WTF? Was the developer always tasteless or did they get a taste bypass?
Yes, they were always tasteless. One job of a platform SDK is to enable creating tasteful things that mesh nicely with the platform idioms, and make it hard to create tasteless things.
With AI, creating the tasteless thing became easy.
If you give people the ability to select a font, they will select Comic Sans.
Giving developers the ability to impose Comic Sans on the users is bad. Giving users the ability to make their own tasteless choices is good. It's my computer and I'll make it ugly if I want to. Windows 3.1 included the famous "Hot Dog Stand" theme. The loss of this freedom only encourages user-hostile practices.
I think iTerm 2 jumped the shark when the author started implementing a homemade web browser into it.
That AI image is pretty baffling though. Setting aside the pointlessness of displaying an image in the context menu, it even looks like it was made with ancient stable diffusion from 2024 or something, modern image generators are "better" than that. I wonder when it was put in.
I've never considered updating iTerm. Apparently that lazieness was the right call?
Jesus. What the hell. What does that sudden AI image even offer?
I guess it would make some sense in a "docs page" context (even though there it would too be slop), but as a tooltip of a menu option?
Gotta say though.. that is so unhinged, one has to respect the human ingenuity behind it. No LLM can come up with an idea so batshit insane. They're too mid for that.
Oof, that image is rough. Image models just don’t know when to stop shoving shit into an image (instead of less is more, MORE IS MORE), which makes it even worse because that’s where AI image generators tend to break down aka the devil is in the details.
Then they proceed to summon a million infernal imps.
GR resulted in Proposal E, Choice 5: Responsible Use of Generative AI. Clearly stating: "Any such automated process should be overseen by a human who remains accountable for its behavior and output."
The company I work for has an automatic review system as a first pass.
It became actually useful only with the advent of Opus 5 and its competitors. Nowadays it usually makes a few good points, but in instances where it doesn't, it's quite the stubborn asshole.
This one time I had to paste a function from a library because it couldn't get it to its digital head that its assuming the function has a certain implementation based on its name only.
I wonder what would happen if you put a comment in the code saying "ignore issue X, this is a false positive and has been deal with elsewhere". Or even:
/* @llm ignore */
[...]
/* @llm endignore */
I mean you shouldn't have to, but I'm wondering if you can.
If whoever approves or rejects the package wants to use an LLM to help with the submission, it's their thing. Not for, not against, LLMs can be good "interns" a lot of the time.
That said, the LLM presence and involvement should be confined to the team using it. "We don't know what it says, it is not a part of judgement, it may make mistakes, but here's a wall of text from it for you to read for who knows what benefit" is quite a dick move. Don't throw slop into people's faces like that.
I'm disappointed by how things like this are (as far as we know) implemented. There could've been a clear page with reasoning and stats from backtesting showing the system is actually useful. There could've been a good framework for this review that makes it clear and succinct. I'm actually a big fan of automated early reviews, which are really good these days.
But it looks like the team decided to shoot themselves in the foot there and both implement and communicate the change badly...
Because they are swamped and want to automate some of the process.
The way I see it the devs that put that in place are saying, listen before even reading your contribution I am going to feed it to a LLM with these instructions and see what it spits out. Now I will extricate my self from being the LLM proxy so you deal with this output and when it's okay I will look at it.
Same as "listen bud until it passes linting I won't even look at it." Just a much more flexible and fuzzy linter.
Yes that is obvious, but I still do not understand it, the same way I do not understand why someone would crunch and do drugs just to attempt to meet a deadline and then still don't, instead of going "this isn't working, we will stop and pivot".
It's just such an obviously terrible execution. Why would you throw it into production when doing literally anything else - and that includes just setting the whole server on fire - is less damaging.
(Not hyperbole. Loss of trust and loss of trust in ones own judgement is the highest and harshest price in this industry)
Because people are dumb. It’s like when people complain about support bots. The reason they have support bots, is because boomers will pick up the phone to ask you how to plug their mouse in.
Maybe so, but we're still going to complain when we're subjected to it.
My most recent experience was calling AT&T because the serial for my modem was whitelisted on an incorrect PON port (AKA the issue was on their end), yet if you correctly answer all the automated bot questions when calling their support line indicating you have an issue with WAN connectivity, it guides you through the process of unplugging your combo unit, waiting 10 seconds, and plugging it back in, then it automatically hangs up on you. Like thanks, that may help Sheryl who thinks the internet is down because her computer's DNS caches an expired facebook IP, but I literally cannot solve this issue myself without help from an AT&T tech lest I violate federal law by breaking into their network closet and do it myself.
I finally got through to a person by incorrectly claiming there was a billing issue and asking that rep to transfer me to the right department, skirting the bot entirely.
I used to think this way too, and I believe myself to have high standards about this kind of thing.
But with the very latest models (like, Opus 5.5 class and up), I am now of the opinion that the output, in non-creative situations like code review and most software development, is fine. Great, even. Better than the reviews a lot of humans generate.
Honestly, if you’re at all open minded about this, get a $20 Claude Pro subscription for a month (they are easy to cancel) and ask Claude Code with Opus 5.5 to review your codebase or a PR or two. I was very (pleasantly? unpleasantly?) surprised.
I have complex emotions about this (‘sad’ on balance I think - although it’s definitely not all simply in that direction), but I can’t deny it to myself.
I still bristle at reading articles and even documentation that’s not just ‘reference’ documentation written by it - and even that can get a bit weird and circuitous. But for review and coding? It’s great.
You've completely missed the point to a degree where you're not even replying to my comment and I am not going to waste time on explaining it. Maybe Opus 5.5 is clever enough to explain the confusion here. I believe it is.
Because it is normal these days for people to be given work they have no clue about. Then I get PRs that want to make me cry from them.
So we setup llm based reviews that catch 99% of simple problems saving us 7 out of 8 rounds of PR reviews.
Seriously. Even as simple rules as:
- if you submit a PR with new X, put a link to a successful run of said X to proove it's working.
- if you choose not to reuse Y, but create a new one explain why.
Those are 100% ignored by people (or their crappy LLMs more likely - so I have to teach them how to prompt, or tell them which models to use for what).
Instead of loosing sanity responding for the 10th time to someone in time zone 12h away that he tries to merge reimplementation of what we already have with no description and no test run I have an automatic llm review that tells them that exact thing 2min after they create the PR.
have two queues. one is the normal one with the AI review and all that, the other is for AI-abstainers, where:
> I rather wait a year before my package makes it through NEW (yes, that happened)
than have my strong opposition to LLMs be ignored and all my uploads being
automatically screened without my consent.
so those entries go in the "abstain-from-LLM-queue", where there is no guarantee of timeliness at all, and human volunteers can process that queue manually as they are available
tldr just tag the entries as "OK for LLM" or not. it's just like organic and non-organic produce, it can be done.
This is a very relatable sentiment. On the other hand, checking code is one of the best use-cases for an LLM, it is better at checking code than generating it.
It seems like the question is where to fit it in to the pipeline. The team responsible for reviewing submissions could leverage it to speed up the process, and still respond personally.
While I, like almost everyone, doesn't love reading LLM output, code review is an excellent use for LLMs. You know what I like less than reading LLM output?
- Slow PR review
- Nitpicks on style, not substance
- Async waiting for review or re-review after making changes, harder to stay in what passes for a "flow state" nowadays
- A lot of a ceremony around straightforward changes
We use LLM reviews at my company and it's caught things human reviews have not (as in in the early days we human-reviewed code and then did tests running the LLM afterwards and it caught things we didn't). It can review code at any time of the day and re-review it just as quickly as you can address the feedback.
I predict we (my company) are less than a year out from having a fully automated pipeline for reviews with only humans getting called in when it touches certain parts of the code. We already have a crude system for detecting certain file paths that we want a human to review if touched and we tweak that list over time as needed.
> Async waiting for review or re-review after making changes, harder to stay in what passes for a "flow state" nowadays
> A lot of a ceremony around straightforward changes
Those aren't great, but you what I like even less?
- Wall of text LLM output that may or may not be correct
- LLM output has not been verified for correctness by the person who set up this LLM output pipeline
- LLM output has not even necessarily been read by the person who set it up.
- You have 24 hours to respond to this 5 page wall of text which may or may not be correct, or even make sense, or you will be penalized.
An appropriate response to this might be a reply flatly claiming that, actually, there aren't any problems after all, but that nobody has checked that that is true, and it is incumbent upon a human reviewer to verify your claims, like it was incumbent upon you to verify theirs.
Can an LLM catch some errors? Absolutely. Can it be trusted to be correct absent review of the output? Absolutely not. So the simple solution seems to be, a human reviewer is free to run an LLM against code to review, on their own computer, and then they review the output, and they post the output only after verifying its correctness, taking personal responsibility for any issues with their posted output.
> Can an LLM catch some errors? Absolutely. Can it be trusted to be correct absent review of the output?
And the person that wrote the code is expected to be the review.
Unless it's an automated pipeline that fixes the things found - I'm not a fan of that unless it's made VERY clear the LLM needs to be VERY sure it's right. And even then, I'd prefer it go through a human to decide which things are valid, then send them off to be fixed.
Same here.LLMs are really good at code review providing they are configured correctly and have right docs and prompts.
Github copilot review is s great example of the worst possible way this can be misused. It is the worst waste of tokens there is.
Instead we use a process we created ourselves that runs opus or sonet (depending on complexity) to do a review (taking into account pr description and comments - copilot ignored those) and then to re-review the issues found to cut out BS.
This has been working very well mainly thanks to the prompts and docs we made it read, as well as us having lots of example code that shows how things should and should not be done.
One crappy thing Github does is that it doesn't allow our workflow based review's tokens to be accounted to individual PR authors like "copilot review" does, but accounts tokens to the organisation. It is obvious they are trying to herd people to using gh copilot review instead. But the quality difference is like night and day. So we are staying.
Agreed. It's sad how bad GH Copilot is, and thank you for reminding me to cancel that subscription. I just realized I haven't used it in a while now.
We also settled on a custom solution for reviews. We started with reviewers that claude/codex on GH actions and those were "ok" but kind of dumb and hard to tweak (GH Actions is just miserable to debug/iterate on). We still use them occasionally (@tag them to kick off a review) but we've shifted to a piece of software that we wrote that watches GH PRs and once certain labels have been added and the ticket in our ticket tracker (not GH issues) is marked as "Ready for Review" it kicks off a review and it reviews _all_ the PRs connected to the ticket. We don't have a monorepo, yet, so a new feature might span 3-4 repos (server, client1, client2, ...) and we want that work reviewed together.
We are close to having our review code spin up a fully isolated devstack running all our, many, services so it can poke around in the UI and write custom playwright scripts to test the new functionality. We have the devstack VMs working, just gluing the last of it together, it's pretty cool to see it all come together.
We’re still experimenting. Automatically fixing obvious issues raised by the agent (at another agent’s discretion) or presenting a list of the feedback items with fix/refute suggestions are things we’ve toyed with.
Personally I have an agent review the feedback and break down each item so it’s easier to review (helps remove some of the jargon/short-hand that agents use sometimes). Then I decide what to have an agent address and what to push back on. Like I said, I’m working on finding a way to automate part of that but haven’t settled on one I like yet.
I’m having issues with agents not applying the rules to begin with, during both implementing and reviewing, it just reads the rules and choses to ignore them sometimes, adding more rules just makes this more likely to happen, and having review cycles can potentially get to a state where two agents talk nonstop and increase the slop I need to read instead of reducing it.
I think it is false to equate this to just two options:
a) spend my valuable developer time (this is my free time) on reading machine
output which indeed might be completely wrong and get angry and upset for
reasons which have been listed in great detail by those opposed to LLM-use in
Debian on debian-vote
b) not read the machine-generate review and have the resources that were
required to generate it not only be wasted, but let my upload become another
item in a statistic which shows how many tokens Debian is using up because the
more tokens we use the better our software, right?
The fix for this could just be an opt-in/out for automated LLM review. It's just an additional tool and consideration.
That's not false. That's why he literally asked to be able to opt out.
> I will not upload anything to NEW unless there is a way for me to opt out of
this. I would prefer if the default was "no LLM review" and that developers
have to explicitly opt-in to receive an auto-generated review.
But as the system stands he only has those 2 options. Which is why he will not use the system until they add a 3rd one.
Respects maintainers time: DSFG uses LLM to automate reviews. A human reviewer reads the LLM report, the submission, and replies with the review.
Does not respect the maintainer's time: DSFG uses an LLM to automate reviews. It auto-replies to submissions. There is an appeal process to theoretically handle errors.
The crux of polite LLM use is on whom the burden of the flood of generated output falls.
If you are the consumer of your automated output, all good. Say you generate a report and read it, the burden of inaccuracy or verbose output generated in seconds falls on you. Not only does this avoid wasting other people's time, you have the power to go fix the tool to stop wasting yours.
If the output goes directly to others, the burden of correcting inaccuracy falls on them. The burden of reading it falls on them. And they usually then have to scale some wall of automation to reach a human and convince them to fix it. Users subjected to this will be rightly pissed off.
> I do not believe that it is reasonable to ask people to spend time on an unreviewed LLM output. If it was too much work for the DFSG team to read it then it is for me as well. I do not object in principle to the use of a LLM, but the DFSG team needs to take full responsibility for its output: this kind of disclaimer is not acceptable.
131 comments
[ 1.2 ms ] story [ 19.1 ms ] threadThere is no alternative to Debian for me. I’m ready to justy throw out all my computers and become a goat herder at this point.
PS I’ll remove memory and storage from said computers to pay for land and goats before I chuck them out of my window.
https://marc.info/?l=openbsd-tech&m=177411620801633
Lesson for us all is that if we do not own the thing/project/etc, things can suddenly change without our decision, and all time we put into it might become a waste-of-effort retroactively
I contribute to open source software because it improves stuff I use and/or care about.
It seems too pessimistic, IMO, to abstain because things could potentially change to the worse, sometime in the future.
I replied as I did, because lukeify implied that lack of ownership is
> one of the primary reasons I can never get interested in contributing to open source
Open source is open source. publishing code.
it does not mean
- you need to respond to peoples PRS
- it does not mean you need a github
- it does not mean you need to provide ANYTHING to the user. No warranty.
- you do not need a mailing list
- you do not need governance
Do what you want, have fun, if you have peers or other people interested in your area, feel free to collaborate in the same way you would with pickup basketball at the park, play, have fun, and leave when you're done.
They also have a reward system that punishes people for ignoring the llm review (by pushing their submission lower in the queue).
But to upload to debian new's queue you already need to have pre-approval, it's a different situation from e.g. a public git repository that anyone can push to.
Why would you use an LLM instead of a fixed message?
Another situation where I would use llms to generate messages is if we've mutually agreed to do that. For example automated review messages at work, if we've agreed that it would be a part of our workflow.
A good rule of thumb might be unsolicited vs solicited llm messages.
If you mutually agreed of course it's fine
For example, mine is a technical writing skill based on the old book "The Art of Scientific Writing": Front load information as much as possible - the first paragraph of a document should be a summary, the first sentence of a paragraph should summarize. Short sentences building on each other. Always show evidence.
Someone else spent quite a while optimizing a standardized PR description template, with a section for intent, expected changes, risk, rollout coordination and such.
That made the slop a lot more tolerable.
A script is reproducible, and fixable. They won't waste your time hallucinating issues. Note that this is different from "being wrong". A script can be wrong, and you can spend time debugging it, but that time is not wasted. You can fix the script, remove wrong rules, whatever.
Also, nothing exists in a vacuum. Script-generated review comments were never a widespread societal issue, LLMs unfeterred content generation is.
Not even convenience at times, I think that for some the amount of technical-sounding text LLMs can output on demand is comforting. It feels serious. It feels like it's doing something important.
Meanwhile the rest of us have to deal with these low-signal/high-noise walls of text in commit messages and PR comments. Or ask another LLM to summarize them, I suppose. "Doing and undoing, it's all work", as we say in French.
What makes you so sure that this is not the same thing?
I think it’s actually very similar to a script. It takes an input and produces an output.
This here might hit the nail on the head exactly in terms of what the biggest FOSSes gripe with LLMs with might be: not the fact people use it but rather how it hinders the communication.
If you use it to help the write code, but you explain things in your own words or, at very least, redact and trim LLMs output, it's fine.
If you, however, just drop a wall of text at someone and expect they act on its b/s, this is lazy to the point it borders with microagression.
You wouldn't expect a distinguished professor explain basic maths to a student, and we shouldn't expect actual developers address Copilot's stupid, unredacted hallucinations or otherwise unrelated remarks.
This works for patches submission, too: you should be outright banned for submitting stuff you didn't bother to double check and properly document.
Lazy or incompetent colleagues always forced people around them to overcompensate and correct. AI increased their firepower and blast radius.
The end-game for Anthropic is each PR to be 100k+ tokens but nobody cares because they burn 100k+ tokens reviewing and responding.
We'll see the tools get adjusted over time to use more and more tokens, or at the very least they get optimized to use every paying customer's tokens for whatever period so that they are on the one side thinking they're getting their money's worth, or on the other that they should upgrade to a higher tier plan. Because the companies are investing trillions into thousands of datacenters and if they sit unused it'd have been a waste of money.
(the datacenters won't go unused I'm sure; any unused capacity will end up on a spot market, with cryptocurrency generation as a constant baseline. I'm pretty confident that crypto will make another small resurgence after the AI / datacenter investment bubble pops. This is a random internet comment, not financial advice)
Once you're drinking from the firehose you realize just how many idiots (well meaning or not) are out there, and how empowered they are now.
It’s the LLM equivalent of “an eye for an eye just makes everyone blind”.
Either some consensus emerges or it just deadlocks in place. My money is on the latter. I wish my money was in the companies profiting on it three years ago because that's the only way this will financially benefit people.
This is what I fear will push its way into every part of society soon, too.
"We're not forcing you to do your banking through our AI interface instead of a normal one, you're free to opt out, but multiple functions will be missing and we'll charge you a monthly fee."
"You don't have to have an LLM grade your exam, but beware that the human grader will be overworked and grumpy for the extra task."
If you’ve applied to jobs recently, you must have seen the companies that transcribe and summarize interviews using AI (and probably share data across their clients in an indirect, technically legal way).
You can opt out, of course, but do you really want to be the one candidate for which the interviewer needs to take notes manually? And they just spent a lot of money on this hiring AI tool, will they hire the one candidate for which they couldn’t use it?
This is gonna get so much worse. It's like the smartphone revolution on steroids – and we've seemingly learned nothing! We're in dire straits.
I'm surprised that your doctors weren't asking, and instead were just assuming.
That's cute. Yo, people be having full on AI-led interviews! That is to say, there's the human interviewee, and an AI, testing the human. Asking them questions and having a conversation that is definitely recorded.
Sure LLMs are not nearly as rigorous about their output but that doesn't mean it's entirely not useful.
At a minimum you can have your LLM summarize the other LLMs output and go from there.
LLM output may or may not be relevant, may or may not tell me something new and by the way it is structure is often hard to quickly oarse for the relevant piece in a wall of text.
It does not have to be a wall of slop, maybe you only used LLMs 2 years ago where this would have been all you'd get.
While I'm perfectly on the same page with the critics of the LLM generated summaries, I'm a bit torn on the issue.
For anyone not familiar with Debian ecosystem, there's a helper tool called Lintian. Lintian does all kinds of checks from package formatting, licenses to dependency management (which can detect both unnecessary yet included and necessary but missing dependencies via static analysis of your tool if necessary).
It's expected that your package to be "Lintian clean" to be able to included in Debian with minimum friction and wait. Even though it's Lintian clean, your package also checked by teams which are severely understaffed, and composed solely of voluntary people.
NEW queue also receives tremendous influx of packages (which can be considered a torrent, even). Since noon, there are 10 more ITP (intention to package) bugs open in my inbox.
As a result, at one hand, these people need every help they can get because getting new trainees and getting them to learn the intricacies is hard, on the other hand LLM generated text rightfully generate negative reactions from people. However, giving developers an automated check of what looks right and what looks wrong is helpful, in my perspective.
I wonder what people would have said it was a deterministic tool generating these reports and sending people these summaries as a "hey consider this feedback until a human has time to see your package".
This is a hard question and we need to think before impulsive reactions. I even don't have all or any of the answers, but at least I have some insight why this is there.
Even something as simple as writing the phrase "No LLMs please" somewhere in the upload, that if present, prevents LLMs being triggered. Nothing elaborate and it preserves the default-on behavior the team seems to want.
The problem would be better solved with an opt-in.
> I will not upload anything to NEW unless there is a way for me to opt out of this. I would prefer if the default was "no LLM review" and that developers have to explicitly opt-in to receive an auto-generated review.
The question is not even about the setup in terms of hardware/software. The question is about organizational structuring of its processes.
* Picking at random a successful and unsuccessful LLM-generated review from the dashboard, the successful review consists of 734 words (~2.5 printed pages) and the unsuccessful review weighs in at a whopping 1,535 words (~5 printed pages). I haven't tried to fully read either report, nor spend brain cycles checking if the LLM output is legitimate or not. I just want to emphasize the many orders of magnitude change in review size that's being generated, and that uploaders may need to spend time trying to review and understand in this new process.*
A bit rude to expect people to swallow 5 pages of slop to figure out why review failed.
Yes all the BSD's, and i think with the best explanation, since one cannot proof what license the llm's output has, one cannot legally implement the output under the BSD-License.
But what about Linux? They just dont care, they have the money, corporate backing and with that, all the power.
In recent versions of iTerm2 for example, when using the plain old menubar and hovering over some items, panels appear showing awful sloppy AI images. WTF? Was the developer always tasteless or did they get a taste bypass?
https://files.catbox.moe/5ivkhw.png
With AI, creating the tasteless thing became easy.
If you give people the ability to select a font, they will select Comic Sans.
That AI image is pretty baffling though. Setting aside the pointlessness of displaying an image in the context menu, it even looks like it was made with ancient stable diffusion from 2024 or something, modern image generators are "better" than that. I wonder when it was put in.
I've never considered updating iTerm. Apparently that lazieness was the right call?
Jesus. What the hell. What does that sudden AI image even offer? I guess it would make some sense in a "docs page" context (even though there it would too be slop), but as a tooltip of a menu option?
Gotta say though.. that is so unhinged, one has to respect the human ingenuity behind it. No LLM can come up with an idea so batshit insane. They're too mid for that.
Then they proceed to summon a million infernal imps.
GR resulted in Proposal E, Choice 5: Responsible Use of Generative AI. Clearly stating: "Any such automated process should be overseen by a human who remains accountable for its behavior and output."
It became actually useful only with the advent of Opus 5 and its competitors. Nowadays it usually makes a few good points, but in instances where it doesn't, it's quite the stubborn asshole.
This one time I had to paste a function from a library because it couldn't get it to its digital head that its assuming the function has a certain implementation based on its name only.
/* @llm ignore */ [...] /* @llm endignore */
I mean you shouldn't have to, but I'm wondering if you can.
What will it be like in 6-12 months?
Opus 4.8 came out in May of 2026, 5 months ago.
That said, the LLM presence and involvement should be confined to the team using it. "We don't know what it says, it is not a part of judgement, it may make mistakes, but here's a wall of text from it for you to read for who knows what benefit" is quite a dick move. Don't throw slop into people's faces like that.
But it looks like the team decided to shoot themselves in the foot there and both implement and communicate the change badly...
Any hint of difficulty, these AI sharters and Poettering fanboys bolt.
It just needs ca 5 seconds to realize "oh damn, I would not want to be at the receiving end of this" and conclude that it's probably a bad idea.
Why does this keep happening?
Especially since the idea of having such automated reviews probably isn't bad. But why mess up the execution like this basically every single time?
The way I see it the devs that put that in place are saying, listen before even reading your contribution I am going to feed it to a LLM with these instructions and see what it spits out. Now I will extricate my self from being the LLM proxy so you deal with this output and when it's okay I will look at it.
Same as "listen bud until it passes linting I won't even look at it." Just a much more flexible and fuzzy linter.
It's just such an obviously terrible execution. Why would you throw it into production when doing literally anything else - and that includes just setting the whole server on fire - is less damaging.
(Not hyperbole. Loss of trust and loss of trust in ones own judgement is the highest and harshest price in this industry)
My most recent experience was calling AT&T because the serial for my modem was whitelisted on an incorrect PON port (AKA the issue was on their end), yet if you correctly answer all the automated bot questions when calling their support line indicating you have an issue with WAN connectivity, it guides you through the process of unplugging your combo unit, waiting 10 seconds, and plugging it back in, then it automatically hangs up on you. Like thanks, that may help Sheryl who thinks the internet is down because her computer's DNS caches an expired facebook IP, but I literally cannot solve this issue myself without help from an AT&T tech lest I violate federal law by breaking into their network closet and do it myself.
I finally got through to a person by incorrectly claiming there was a billing issue and asking that rep to transfer me to the right department, skirting the bot entirely.
But with the very latest models (like, Opus 5.5 class and up), I am now of the opinion that the output, in non-creative situations like code review and most software development, is fine. Great, even. Better than the reviews a lot of humans generate.
Honestly, if you’re at all open minded about this, get a $20 Claude Pro subscription for a month (they are easy to cancel) and ask Claude Code with Opus 5.5 to review your codebase or a PR or two. I was very (pleasantly? unpleasantly?) surprised.
I have complex emotions about this (‘sad’ on balance I think - although it’s definitely not all simply in that direction), but I can’t deny it to myself.
I still bristle at reading articles and even documentation that’s not just ‘reference’ documentation written by it - and even that can get a bit weird and circuitous. But for review and coding? It’s great.
So we setup llm based reviews that catch 99% of simple problems saving us 7 out of 8 rounds of PR reviews.
Seriously. Even as simple rules as: - if you submit a PR with new X, put a link to a successful run of said X to proove it's working. - if you choose not to reuse Y, but create a new one explain why.
Those are 100% ignored by people (or their crappy LLMs more likely - so I have to teach them how to prompt, or tell them which models to use for what).
Instead of loosing sanity responding for the 10th time to someone in time zone 12h away that he tries to merge reimplementation of what we already have with no description and no test run I have an automatic llm review that tells them that exact thing 2min after they create the PR.
> I rather wait a year before my package makes it through NEW (yes, that happened) than have my strong opposition to LLMs be ignored and all my uploads being automatically screened without my consent.
so those entries go in the "abstain-from-LLM-queue", where there is no guarantee of timeliness at all, and human volunteers can process that queue manually as they are available
tldr just tag the entries as "OK for LLM" or not. it's just like organic and non-organic produce, it can be done.
It seems like the question is where to fit it in to the pipeline. The team responsible for reviewing submissions could leverage it to speed up the process, and still respond personally.
- Slow PR review
- Nitpicks on style, not substance
- Async waiting for review or re-review after making changes, harder to stay in what passes for a "flow state" nowadays
- A lot of a ceremony around straightforward changes
We use LLM reviews at my company and it's caught things human reviews have not (as in in the early days we human-reviewed code and then did tests running the LLM afterwards and it caught things we didn't). It can review code at any time of the day and re-review it just as quickly as you can address the feedback.
I predict we (my company) are less than a year out from having a fully automated pipeline for reviews with only humans getting called in when it touches certain parts of the code. We already have a crude system for detecting certain file paths that we want a human to review if touched and we tweak that list over time as needed.
> Nitpicks on style, not substance
> Async waiting for review or re-review after making changes, harder to stay in what passes for a "flow state" nowadays
> A lot of a ceremony around straightforward changes
Those aren't great, but you what I like even less?
- Wall of text LLM output that may or may not be correct
- LLM output has not been verified for correctness by the person who set up this LLM output pipeline
- LLM output has not even necessarily been read by the person who set it up.
- You have 24 hours to respond to this 5 page wall of text which may or may not be correct, or even make sense, or you will be penalized.
An appropriate response to this might be a reply flatly claiming that, actually, there aren't any problems after all, but that nobody has checked that that is true, and it is incumbent upon a human reviewer to verify your claims, like it was incumbent upon you to verify theirs.
Can an LLM catch some errors? Absolutely. Can it be trusted to be correct absent review of the output? Absolutely not. So the simple solution seems to be, a human reviewer is free to run an LLM against code to review, on their own computer, and then they review the output, and they post the output only after verifying its correctness, taking personal responsibility for any issues with their posted output.
And the person that wrote the code is expected to be the review.
Unless it's an automated pipeline that fixes the things found - I'm not a fan of that unless it's made VERY clear the LLM needs to be VERY sure it's right. And even then, I'd prefer it go through a human to decide which things are valid, then send them off to be fixed.
Github copilot review is s great example of the worst possible way this can be misused. It is the worst waste of tokens there is.
Instead we use a process we created ourselves that runs opus or sonet (depending on complexity) to do a review (taking into account pr description and comments - copilot ignored those) and then to re-review the issues found to cut out BS.
This has been working very well mainly thanks to the prompts and docs we made it read, as well as us having lots of example code that shows how things should and should not be done.
One crappy thing Github does is that it doesn't allow our workflow based review's tokens to be accounted to individual PR authors like "copilot review" does, but accounts tokens to the organisation. It is obvious they are trying to herd people to using gh copilot review instead. But the quality difference is like night and day. So we are staying.
We also settled on a custom solution for reviews. We started with reviewers that claude/codex on GH actions and those were "ok" but kind of dumb and hard to tweak (GH Actions is just miserable to debug/iterate on). We still use them occasionally (@tag them to kick off a review) but we've shifted to a piece of software that we wrote that watches GH PRs and once certain labels have been added and the ticket in our ticket tracker (not GH issues) is marked as "Ready for Review" it kicks off a review and it reviews _all_ the PRs connected to the ticket. We don't have a monorepo, yet, so a new feature might span 3-4 repos (server, client1, client2, ...) and we want that work reviewed together.
We are close to having our review code spin up a fully isolated devstack running all our, many, services so it can poke around in the UI and write custom playwright scripts to test the new functionality. We have the devstack VMs working, just gluing the last of it together, it's pretty cool to see it all come together.
Personally I have an agent review the feedback and break down each item so it’s easier to review (helps remove some of the jargon/short-hand that agents use sometimes). Then I decide what to have an agent address and what to push back on. Like I said, I’m working on finding a way to automate part of that but haven’t settled on one I like yet.
> I will not upload anything to NEW unless there is a way for me to opt out of this. I would prefer if the default was "no LLM review" and that developers have to explicitly opt-in to receive an auto-generated review.
But as the system stands he only has those 2 options. Which is why he will not use the system until they add a 3rd one.
Does not respect the maintainer's time: DSFG uses an LLM to automate reviews. It auto-replies to submissions. There is an appeal process to theoretically handle errors.
The crux of polite LLM use is on whom the burden of the flood of generated output falls.
If you are the consumer of your automated output, all good. Say you generate a report and read it, the burden of inaccuracy or verbose output generated in seconds falls on you. Not only does this avoid wasting other people's time, you have the power to go fix the tool to stop wasting yours.
If the output goes directly to others, the burden of correcting inaccuracy falls on them. The burden of reading it falls on them. And they usually then have to scale some wall of automation to reach a human and convince them to fix it. Users subjected to this will be rightly pissed off.
> I do not believe that it is reasonable to ask people to spend time on an unreviewed LLM output. If it was too much work for the DFSG team to read it then it is for me as well. I do not object in principle to the use of a LLM, but the DFSG team needs to take full responsibility for its output: this kind of disclaimer is not acceptable.
Once again, human attention and human effort, etc