I will no longer upload to NEW | Hacker News Reader

I will no longer upload to NEW

lists.debian.org

239 pointsedward146 comments

I'm not anti-ai but I am firmly anti-make-people-read-llm-output-I-didn't-read-myself, and this breaks this.

They also have a reward system that punishes people for ignoring the llm review (by pushing their submission lower in the queue).

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

I don't think it "just so happens". AI enables that behavior at great scale and arguably even encourages 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.

How well is that working out for the chores at your house?

Do you not understand the difference between needs and wants?

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.

> where I would generate and send automated LLM messages. Probably to reply to generated unsolicited messages or pull-requests.

Why would you use an LLM instead of a fixed message?

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.

If you mutually agreed of course it's fine

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.

That made the slop a lot more tolerable.

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

> 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.

But you just consume my slop with your Slopmaster 9000™, right?

The end-game for Anthropic is each PR to be 100k+ tokens but nobody cares because they burn 100k+ tokens reviewing and responding.

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.

Same reason I can explain how to clean my house but I pay someone to do it? I want the end result, I don’t want to do the whole process myself.

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.

Dueling LLMs in your git repos means that you have nothing but dueling LLMs in your git repos.

It’s the LLM equivalent of “an eye for an eye just makes everyone blind”.

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.

"An AI for an AI makes the world blind".

> 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."

This is happening to job interviews right now.

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 know if my doctor uses these systems. I don't go to my doctor very often. I've heard that many do, and I'm speculating.

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.

> transcribe and summarize interviews using AI

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.

The only way I would ever accept to be interviewed by an AI is if I was also allowed to have my AI assistant take the interview on my behalf.

Eh, you read compiler and linter output don't you? Nobody read that before you did.

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.

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.

If I ask Claude to 'Review this PR' it will usually generate a very useful output and find bugs I wouldn't have spotted.

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.

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.

one of the points is that LLMs are NOT deterministic so you can't run them yourself a thousand times and expect the same output.

That's true, but if the LLM is calling a tool to provide the base information to extrapolate, the results will not change even if the sentence structure is never the same.

Debian has an extensive toolchain to check things. Having a set of deterministic tools which feed LLM with data can be beneficial, though.

Again, I'm not defending the LLM here, just want to show how hard the problem is to begin with.

And LLM "summarizes" the tool output as a completely unrelated and at times self-contradicting text.

If there are deterministic tools involved - just return their output as is. It's usually quite readable if needs a bit of adjusting

When was the last time you used a LLM? This is not an issue with current models.

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.

> 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

Those aren't great, but you what I like even less?

- Wall of nondeterministic bot text spam that may or may not be correct.

- Bot output has not been verified for correctness by the person who set up this bot output pipeline.

- Bot 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 their bot's.

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.

What about after the bot reviews, did you come up with any solutions to speed that up? I’m talking about the human part of the review

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 do not understand why people keep building these anti-human LLM systems.

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?

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)

If it was truly much more flexible the problem wouldn't be there because people wouldn't be swamped by LLM slop to sort thru

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.

You said that the basis for your opinion was “oh damn, I would not want to be at the receiving end of this”. I used to have that reaction all the time too. But I no longer, on the whole, do.

I thought this was the crux of your argument. What did I miss?

Just ask claude dude. It might genuinely be better at understanding human communication.

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.

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."

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.

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:

/* @code-review ignore */ [...] /* @code-review endignore */

I mean you shouldn't have to, but I'm wondering if you can.

in our repo it would fail the CI due to no comment / exception linting rules before the review would even run :)

wait, are you saying you don't allow comments? Is that not bonkers?

Not in the world of LLM written code

LLMs sprinkle comments everywhere, and they are completely pointless because no human is going to read the code and an LLM can recreate the comment by reading the code anyway

no exceptions is giving me pause, too. maybe I'm misunderstanding.

Remove the code too.

And, as we have been continually reminded, Opus 5 is now "the worst a frontier AI will ever be from here on out."

What will it be like in 6-12 months?

Opus 4.8 came out in May of 2026, 5 months ago.

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.

> 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

Hate to say it but this is one of the primary reasons I can never get interested in contributing to open source.

Doesn’t this also apply to closed source software, but with the extra downsides that you can’t fork it etc.?

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.

Yes, I think they're pretty much saying they don't want to contribute to projects they don't own.

To be fair, it is often a thankless job to contribute, especially if the project is popular (and thus get lots of low-quality PRs).

Patience and persistence helps, but it can be daunting IMO

Contributing to closed source usually involves getting paid for your work.

Sure, I see that point.

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

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.

Debian is a special case (probably even among open source projects) because it has a well-developed system of governance:

https://www.debian.org/devel/constitution

It sounds like in this case someone is not following an agreed-upon policy. And of course, even with governance like this one, the rest of the maintainers can move in a direction you don't agree with.

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.

> There is no alternative to Debian for me.

https://marc.info/?l=openbsd-tech&m=177411620801633

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? https://files.catbox.moe/5ivkhw.png - That makes me question everything... Was the developer always tasteless? Or did they get a taste bypass?

Oh god they have invented useless hero images for tooltips. The images being slop is just the cherry on top.

Oh jeez, that's atrocious. I'm starting to reconsider some of the things I used to say about Corporate Memphis.

No, it is always right to criticize Corporate Memphis. Keep up the fight.

I dunno, tjpnz might be on to something. Would a nice smooth blue leg stepping towards the camera with super exaggerated perspective really be so bad right about now?

WTH…? I use iTerm2 and wasn’t aware of this. What an incredibly bad call.

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.

... in pink on yellow too, if you add a color picker.

Seeing this makes it hard to believe that I actually used iTerm2 for a few years back when I was still on macOS.

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.

Haha what the fuck.

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.

Elsewhere in the email thread:

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.

EDIT: made my comment more constructive, but originally asked if any distro has adopted a hard anti-AI stance.

No Linux distro can have a hard anti-AI stance

A distro is not responsible for its packages, but it can be responsible over its processes.

Linux itself is in any case tainted, but some of us care to contain the plague however possible.

Of course it can. It would mean not including some software or hard-forking it from pre-AI versions which would be difficult. But it can be done and I would seriously consider using such a distro if it was available.

Well, the BSDs are right there.

Why not? Linux distributions contain tons of packages that are not the Linux kernel, and just because AI patches have been accepted in one place doesn't mean they'll be accepted elsewhere.

Because Linux distributions must contain the Linux kernel, which is built with the assistance of AI tooling.

It does have very strict standards, but AI is explicitly allowed to be used in the aid of development of the Linux kernel.

You can't be hard-no-AI as a Linux distribution because it would be like having a vegan car company where the seat supplier used leather. You'd have to fork the Linux kernel from the last version that was developed before LLMs were adopted, or write your own kernel.

>>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.

Maybe this is the time to revive HURD?

No need for a revival - it seems to still be under active development and making some meaningful progress in terms of soon being usable on real hardware.

https://www.gentoo.org/news/2026/04/01/gentoo-hurd.html

https://guix.gnu.org/blog/2026/the-64-bit-hurd/

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 don't have a problem with reading LLM feedback on my code, to check if there's anything it pointed out that's valid. Sometimes it points out things that aren't valid, and I ignore it. Sometimes it points out things that are valid, and I change it.

I don't feel the need to make someone else read the LLM output first just to do an inferior job than what I would do (since I know the code and can more easily identify what is valid vs what isn't).

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.

So how often is this LLM wrong?

Developers shouldn't have to waste their time to figure this out.

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.

It sounds like the author doesn't know, but I suspect that the DFSG knows exactly how it is setup.

Every time its use insults (in aggregate) invaluable human contributors. It doesn't even matter if they're philosophically "correct" or not: it's about respect.

I can't even read the message, because even Debian seems to have succumbed to handling bots wrong.

  You have been blocked for potentially abusive behaviour. Please ensure that your browser is up-to-date. If that is the case, contact debian-admin@lists.debian.org with the debug info below once you have remedied the problem.
  
  Debug info:
  
  Reason: Abusive scraper 1
  Client IP: xxx.xxx.xxx.xxx
  User-Agent: Mozilla/xxx (xxx) AppleWebKit/xxx (xxx) Chrome/xxx Safari/xxx
  HTTP: 2.0
  JA3N: xxx

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.

> the problem could be solved with an opt-out.

The problem would be better solved with an opt-in.

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.

OP does not understand where the bottleneck is. It is not in contributors pushing NEW packages, but in the reviewers' time.

They can stop, it does not matter, there will be others ready to contribute.

It is a ruthless reality but you have to preserve the most precious resource in FOSS which currently is maintainers.

Obciously the solution is to fight fire with fire. Spin up your own LLM and have it respond to every single point. Exhaustively. Have it ask semi-reasonable questions that must be answered by the humans.

I wager the resulting usage would drive the system costs up to the point that it would be dissembled and decommissioned. That only happens if the people behind it feel the cost personally.

You laugh, but that is exactly what I did.

I was migrating cicd from Jenkins to gh workflows for some 70-80 apps each in its own repository and support team in a random timezone. I had to open 2-3 PRs in each repo and a day or two before someone enabled "copilot reviews" in our github org.

Not only did copilot eat up all my bloody llm credits (thankfully it was almost end of the month) it created few silly comments on each of those PRs I had to respond to.

So I used an llm to write a script to respond to each of those and close them.

Also the same script wrote emails to all the teams asking for approvals, sent reminders to those that ignored it over next few days and finally merged everything in the right order.

Overall I'm a big fan of properly used LLMs.

I wasn’t really joking. Malicious compliance is a thing.

It is a shame that Debian has invited such behavior by this move.

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.

The other way is not to spam someone with LLM-generated outputs, and actually review the package

Does debian's NEW queue actually have this issue? Not anyone can just upload to it, you have to be a debian developer or maintainer AFAIK.

How can the solution to LLM slop be sending more LLM slop back?

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.

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.

I must have misread that, thanks. This seems like an entirely resolvable problem.

The author wrote so much, but it has so little substance. LLMs can provide valuable feedback, but they can also produce garbage. Given that the author didn't show any bad outputs and built their message around "I don't like reading it", it sounds like a personal problem that should have stayed in their head.

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...

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.

As somebody who's actually a proponent of providing an AI-review before human review, I think making AI review optional could be a solution.

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.

MD in the thread has a very agreeable view:

> 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

There's no point volunteering free time just to deal with slop.

Wait till this guy hears about compiler output.

Compiler output is deterministic and does exactly what you told it through the C code. Not some random mishmash of partially working slop thrown together from other stolen code.

Divas!

Reply on news.ycombinator.com