I can see why that doesn't sound great particularly on a team where everyone knows each other and is working together but it totally makes sense for me if I were maintaining a project that was large enough to get a lot of low-effort PRs coming into it.

I'm a world champion bikeshedder, and I both hated this policy and insisted we keep it.

A company is usually already a high-trust environment, where people use real names and have real reputations. So creating an issue cannot serve the purpose of increasing trust.

> I do not want an LLM-generated novel with chapters, bullet points and emojis, just a simple description of the problem in your own voice.

> If I don't see proof of human involvement, then I'm not interested

Have you never seen vibe-slopped PRs?

I suspect that part of it is that people don’t have enough time to mentally incorporate the fix.

Is it weird to submit the MR later, after people have had a chance to digest the issues?

This is the most valuable contribution you had time for, hopefully with a minimum-viable bug reproduction.

Drive-by patches/PRs are usually a net-negative because the maintainer has to reverse-engineer the intent from GenAI code, and then make changes to have it fit in with the rest of project.

> It felt weird to just file issues when my LLM had already spent a lot of time root-causing and fixing the issues

There are countless ways to fix any issue, and only a few right ways (subjectively). The maintainers' role is to decide which ways are right for their project. You shouldn't worry too much about "wasting" code you already generated, GenAI made that step very cheap, but did little for taste and roadmapping.

So at a minimum, you could maybe fish some useful work out. PRs should be the same.

It was already very fuzzy (Excel?). Soon, this line be non-existent.

By vibe. That's what people who believe they can detect AI do.

There's one project where I need to download a new version once in a while and I just rebase my changes.

This is toxic behavior that unfortunately rewards a selfish writer. I'm worried the AI push incentivizes this too much, to where in corporate situations a reader can't say no to doing work for a selfish writer.

They've still put more effort into writing their crackpottery than you will put into reading it, and at worst it's entertaining. The late Ivor Catt's articles on "the death of electric current" - where he expounds the idea that current and indeed electric charge does not exist, because of stuff involving Maxwell's equations where the maths looks about right to me but I'm not a good enough mathematician to prove - were pretty damn odd, but his writing in 1989 on how it would be vital for an interconnected network of computers for information sharing to treat censorship as damage and route around it and some ideas for doing this was bang on the money (as we now see) and his writings on how American business management methods result in the worst possible outcome for everyone that's not already a billionaire have also proven oddly prophetic.

So maybe there's something in the crackpots after all.

At the same time, OP is in the right to reject contributions they don’t want. Nobody providing open-source software is under any obligations to take changes. Forking is still a viable option in 2026. And I don’t think we need an on-demand app store either because the trust issues will still exist for good reason. We can have highly produced software coexisting with LLM agents.

You absolutely don't need LLMs for that.

Its the very description of most corporate JavaScript developers, and probably most Java developers. I say that as somebody who wrote corporate JavaScript full time from 2008-2023. Most of these people had no idea what they are doing. They could throw something together using their favorite abstraction library/framework but then struggled to maintain it. If there were performance or accessibility problems that came up there were only three outputs: hostility, crying, or starting over from scratch. The insecurity was real. You can still see it today. As an experiment take React away and note the response.

You mean some modern version of vb or php?

That is the entire point of low-code and no-code.

As an example, the android options for printing to my outdated brother printer were all terrible (ad supported nokoprint for example), so I used my template to create https://print.walden-gabrielw.workers.dev/ (This one a put a cloudflare worker in front of because it's just a static html+js page and I didn't want to pay for uncached traffic but the principal is basically the same). No one will likely ever use this but me and my wife, but the cost to keep it up is basically 0, the cost to build it was very reasonable, and if it ever breaks I'm fairly confident the latest LLM will be able to debug it without too much trouble.

There's a billion ways of opening a markdown and doing things with it and generally they all coexist hapily

I think there are so many hard questions right now for "Does open source even matter any more?" and many of those questions seem particularly demotivating to me right now, especially because we don't seem to be at risk of getting some, much less better, answers any time soon.

I learned Flask from Grinberg, god bless the man.

Sucks, because open source was a really wonderful thing for many years but we should not continue to create fuel for the theft machines

My lawn == I'm not wasting any of my dwindling old man time on bullshit people vomit out. You want to do that, you fork and leave me out.

I think no answers are needed.

If anyone can build the software they need, no ecosystem will be needed. There will be no maintainers because no one will be using his thing.

If it makes sense (economical, but no limited to it), then it will progress in that direction. If it makes no sense it is a fad that eventually dies out.

There may or may not be a baby in the bathwater. In truth nothing in this bathtub matter too much.

A user would have to be someone who doesn’t have access to an LLM to make bespoke software themselves, and isn’t able to use existing software. I think that’s a vanishingly small segment of people.

Everyone building a software will just mean people can produce code which others might not really care for and might even be particularly be mean. That’s how the Internet works unfortunately.

The current logic seem to be confusing two things. One AI as a technology and wisdom of the crowd using AI. One might ground breaking tech and improve over time while the other might not move the needle at all.

People just want to know you put in the effort, and that you didnt just prompt an AI and hand over completely unchecked slop.

Well, no. A centaur is a normal person with stronger-than-human legs. That is, it's an augmented person who drives the powerful machinery underneath. Think of a person driving a car.

A reverse centaur is the opposite, namely, a machine making the choices and a frail human following them. In this context, a reverse centaur is an AI spitting thousands of LOC for a human to find the good ones.

2. The world has changed in such a way that X now exists

3. You took even a tiny action towards #2

Even if the main goal was #2, Is it really hard to see how there might not be some sense of accomplishment? Many investors take pride in the impact the companies they invested in have on the real world; this is the same thing in the small.

The crux is here somewhere.

A massive group of people (A), don't fully understand or care about code, but they care about arbitrary specific outcomes that serve their needs and desires VS a tiny group of people (B), who initiate, architect and maintain successful projects, who care deeply about the health and cohesion of the codebase over it's lifetime, because that serves everyone.

Group-A is now liberated for better and worse. For the first time they can force their will upon a codebase without understanding. They are making selfish changes, and that's fine, this is hacking for the masses. The problem is they still don't realise these are selfish changes, because they have not been forced to tread the path of the programmer to understand they are selfish changes.

The response from FOSS maintainers seems inevitable from this perspective... But I think what's going to be more interesting is watching how Group-A over time respond to creating their own personal hell.

As group-A accrete more and more unsupervised selfish changes into their forks - at what point will they implode and turn into LLM-token-tarpits, at what point will Group-A notice, and I wonder what their response will be.

For anybody else thought, I get that a LLM is a regression (npi) where you don't have to learn or understand anything .. therefore the personal growth value is moot (except the alleged sales if the person tries to use LLM to create a side business).

For actual devs it's disheartening and caused me real grief seeing how many of them were happy not thinking anymore.

What matters is that they are wasting the time & patience of someone who is doing good work that others benefit from.

Any happiness gained from doing that to someone is parasitic.

And people who get a sense of accomplishment from hitting the jackpot on a slot machine.

Operating an LLM is a strange combination of the two.

I've always said that by only writing ASM can you get any sense of accomplishment from authoring software.

We can now observe a complete reverse centaur. But those of us who go ticket after ticket, metrics of tickets, response times, and all of those management metrics also go directly to reverse centaurs as well.

Now, its not Marshall Brain's "Story of Manna" level each listed action at a time... But it was definitely getting to that point.

Call centers were already absolutely at that point, with completely scripted communications, that that attendant could not deviate from or be fired.

> Presumably at the other end of the ticketing system is other people.

Sometimes. As a systems engineer, tickets can also be generated by other systems as an "immune response" to detected but unfixable errors.

That's a good thing; OSS projects don't want drive-by contributors, they want a community. A small bit of friction is a good thing.

After all, we can see what happens with frictionless contributions.

The problem is that this is increasingly seen as a non-productive workflow slowing everyone else down, so the pressure is growing for writers to just shove massive PRs out the door and reviewers to use LLMs to make that tractable. I suppose those advocates have more faith in LLM output compared to humans than I do.

Then suddenly LLMs happened and it's like the mask is off: no one's reading them still, but also no one is writing them either.

Which is perhaps a drop in the ocean of the insanity which is "we need you to work on the Jira tasks" as basically a job title.

Given that any coding effort relies heavily on a much greater amount of work as a prior than the code you yourself are writing... Why do you feel accomplishment?

Making things is fun, using tools to make things can continue to be fun. I have fun woodworking with hand tools and I also enjoy using my CNC where the job permits. Both bring joy.

In a pre-LLM world, a classic software team would have PMs, designers, and engineers.

Of those three, the PM wouldn't have any real role in writing code. And they would rarely contribute a ton to the design. What they would be contributing is ideas, market insights, coordination, prioritization, etc.

When the product ships, one would expect the PM to feel a real sense of accomplishment. They helped this idea become a _real thing_! All of that pride, despite not writing a single line of code nor polishing any pixels themselves. And I don't think anybody would reasonably look down on them for that feeling.

Same thing with using LLMs. Sure, you didn't write the code. But you caused the thing to exist! That's exciting!

Well also more numerous than human legs... And the whole two torsos thing

https://upload.wikimedia.org/wikipedia/commons/thumb/c/c8/Te...

Because I don't trust myself to review a giant PR. It takes too much cognition to properly review it.

And now that people are making PRs with AI, this is even more important. If the AI was good enough to have coded it, please instruct it to make the changes in reviewable chunks.

How about this crackpot view? Perl vs. Python, which I guess has been replaced by Rust vs. Go - I prefer Python and Go to Perl and Rust, simply because I know them better. If you want me to work in Rust or Perl I don't really care, they're just languages. I'm not as proficient in them, expect it to take longer. Rewrite it all in Rust? Sure. I'd prefer not to, but if that's today's project then shut up and pay my invoice.

Let's see, what other things are wild crackpot ideas around here?

I don't think LLMs are very good.

I don't think self-driving cars solve the right problem.

Permaculture would be better for long-term ecological sustainability and food security than "everyone should be vegan".

Bikes would work perfectly well in American cities if you used enough of them.

By pushing that PR, i might be annoying a grouchy maintainer, but at the same time helping tens or hundreds of other users of the software.

Imho the beauty of open source is as long as you're adhering to the licenses, you can do whatever the heck you want =)

Some of this is the funny situation where the faithful will state: "This writes better code than I do!" and miss the irony of: "yes, yes it does"

Even in these move-fast envs, it should be reasonably apparent for people to realize that the author should be using the LLM to make the PR tractable, not solely using the LLM to shovel out a giant PR + slop PR description.

And the LLMs can often do this - if you ask to restructure or break up a big change differently, they can often make quite reasonable suggestions and help with it. That's just not what you're gonna get if you're lazy. If you want a small LLM-generated change, often you have to start with a big one then ask it to figure out what it can get rid of, since many times it doesn't have perfect model of all the code in it's "head" before it starts spitting stuff out. The big companies have been doing their best to automate this for the last couple of years vs the even-more-blind attempts you used to get, but there's still the issue of the models+tools following generic advice aimed at median codebases vs being intimately familiar with this codebase.

You can go fast without being lazy. And when going fast, in some ways, it's more important than ever to put in that effort to not blowing things up.

Prompting an LLM neither requires comparative effort nor is comparatively challenging, thus it's would be odd to feel a sense of pride from any associated outcomes.

I cannot believe this even requires an explanation.

If you want to stick with the PM analogy, it would be akin to the manager spending 30 minutes writing up a draft spec, passing it off to their employees and then spending the rest of their time watching TikTok in their office. It would be strange if they felt pride in that.

If you can vibecode your app, you can vibecode your cryptography as well.

You may object to it but that, too, would be elitism. And the person vibecoding has no idea why proper cryptography matters anyway. Or why proper anything matters.

This is the ultimate realization of "my ignorance is as good as your knowledge".

I don't think this is necessarily a bad thing.

"Blessed are the humble ..."

I guess it depends on what you consider "better". I've tried using LLMs to write code over the past couple of weeks with extremely mixed results.

The LLM certainly writes more interesting code! They like their cute ASCII/unicode animations, don't they?

It definitely writes a lot more code, none of it actually correct but some of it functionally similar to correct code.

If you like lots of code then I guess that's better. I like less code.

And then there's the bullshit artists.

Just because we never had the option of a chisel before doesn't mean all chiselers are bullshit artists.

Prompting an LLM to produce good code isn't a lot of work for you. Writing hex without an assembler or compiler would be a lot of work for you.

People have ideas, and now they have better tools to turn those ideas into reality. They aren't doing it like you would do it, but they're getting it done all the same, getting their needs met, and enjoying the ride.

Maybe just let people have fun, and when they report that they are in fact having fun... believe them.

But I think most of this stuff is iterative, multi-turn. You type a thing in, see what comes back, and then repeat until you have something that satisfies your desire.

Taking the manager analogy. If you spent 30-minutes writing up a draft spec, waited for the outputs, had a review meeting where you provided good feedback, and then repeated that cycle until the product was done... Again, I think that manager (assuming, of course, that their feedback was useful) should feel some pride in shaping that output!

And it was actually a pretty good feeling. Made me feel that even as a newbie programmer, I was adding value to the community, which I was!

One of the few global Cluade directives I have setup is to never use emojis - and it never has, either in chat output or in code. Don't blame the tool when you don't spend 30 seconds configuring it. It's even easier with AI since you don't have to go digging for some obscure .vimrc snippet - it's literally just plain English.

To be fair, there are plenty of situations where throwaway code is perfectly fine and/or defect risks are low enough to make the trade-off worth it. I don't think a lot of developers are thinking about it in that context, though.

(No unit tests aren't enough)

I think it's much closer to the art commission than it is to a manager who is managing humans, the constraints of the business, customers, etc.

The difference between the skill & effort required to build vs prompt your way to something is orders of magnitude different. If it took just as much effort, people would just do it by hand anyways.

There are way more nuanced uses of LLMs than skill-free “write me a facebook clone.” Like, hey LLM, help me develop tests of X, review this design for X, help me articulate what is wrong with the code for X, give me ideas for simplifying X, suggest optimizations for X, help me debug this failure trace for X, help me apply this refactor across all of X, and on and on. Even these are stupid examples that way over simplify.

I’m super proud of the work I’ve created /alongside/ LLMs. I’ll let it build me development aides and such with little oversight and there’s no skill there. But you can use it deliberately and maintain control, and it’s amazing to have a tool that can look through your code with you from so many angles.

1: https://news.ycombinator.com/item?id=48315309