I opened a PR on a vibe-coded project. The owner asked me to implement additional features

I was browsing Hacker News a month ago when a stumbled upon a post that drew my attention. I went into the project's repository, noticed that there was a feature which I deemed as necessary for this project missing, so I forked the repository, implemented it myself, and opened a pull request. When the project's owner answered to my PR, the language they used was clearly LLM-like and I got asked to implement 4 additional features.

About the project itself

I didn't realize it until after I had made my pull request, but the project's README (and the project as a whole) was what I would expected from an AI-generated project:

The project's scope is to "Turn your contributors into movie stars", that is, by using git (and Github's CLI tool, gh), to generate fancy, movie-like credits for your project. You run it in the target directory and it prints the credits in your terminal. I was kinda surprised that there wasn't a CLI argument for targetting other directories (imagine if each time we had to run ls we had to be at the target directory), so I forked the repository, as I've already written, made my changes and opened a pull request.

Issues I met

I did have 2 issues while making my changes: The first was with the argument parsing, which I already explained below what the issue with that was, and the second what to do with the GIF generation. gitcredits has an option to save the credits as a GIF, but the way it approaches it is awful. Under the hood, it invokes vhs, which is "a tool for generating terminal GIFs from code", it runs itself AGAIN with a --theme argument (which allows you to have references to Spiderman or Matrix in your credits). That means that if someone adds another CLI flag argument (or positional argument, in my case), they have to also modify that code accordingly. Passing the original arguments as-in is out of the question, since the --output will also get passed, the invoked executable will invoke vhs too and it will enter an infinite spiral of program invokation (in my case, the first program terminated after 5 minutes or so. I don't know if it is due to vhs imposing a timeout for such cases or because a gitcredits instace happened to crash).

"Before I can merge this, I’d like to request a few changes"

After the first time I closed the pull request (I was having a bit too much fun with branches on the forked repository), the project's owner replied and asked me to do the following before they could merge my branch onto the repository:

  1. "avoid using os.Chdir() inside getRepoInfo()" - On my behalf, I probably should have used filepath.Join, but that is a change they could have done themselves in 5 minutes

  2. "make the directory a properly parsed positional argument" because "The current parsing logic is fragile" - For reference, here's what that parsing logic looked like when I began: 

    // parse flags
theme := "default"
output := ""
for i, arg := range os.Args[1:] {
    if arg == "--version" || arg == "-v" {
        fmt.Printf("gitcredits %s (%s)\n", version, commit)
        os.Exit(0)
    }
    if arg == "--help" || arg == "-h" {
        fmt.Println("gitcredits - Turn your Git repo into movie-style rolling credits")
        fmt.Println()
        fmt.Printf("Usage: gitcredits [options]\n\n")
        fmt.Println("Options:")
        fmt.Println("  --theme <name>   Theme: default, matrix, spiderman")
        fmt.Println("  --output <file>  Export credits as GIF")
        fmt.Println("  --version, -v    Show version")
        fmt.Println("  --help, -h       Show this help")
        os.Exit(0)
    }
    if arg == "--theme" && i+1 < len(os.Args[1:]) {
        theme = os.Args[i+2]
    }
    if arg == "--output" && i+1 < len(os.Args[1:]) {
        output = os.Args[i+2]
    }
}

    All I did was build upon this code (you can see the relevant changes), that is, extend on the already-fragile parsing logic because that's what I got to work with. I am not going to refactor all that logic for my small change.

  3. "return errors instead of calling os.Exit(1) inside helper functions" - I already had found two occurrences of that practice here and here. Again, as with the previous request, I was following practices that already existed in the codebase.

  4. "Please add tests for the new behavior" - I deemed these tests unnecessary for such a small change on such a small project.

I did answer their requests, of which number 2 and number 3 seemed absurd to me. The project's author replied that "this started as a small utility project", and that they "did not pay enough attention to code quality early on, so some of these patterns do exist in the current codebase" and that they "want to raise the bar going forward rather than add more of the same patterns", after which they reiterated the same claims and saying that if I "want to update the PR in that direction," they are "happy to review it again". I then closed the PR and detached my fork from the parent repository. From what I've seen, they implemented my changes themselves.

Unfortunately, that isn't the first time I've had to deal with nonsensical LLM-generated text.

Wikipedia: LLMs are not welcome

Wikipedia recently adopted a strict no-LLM policy after a RFC, but even before that, AI-slop wasn't welcome on Wikipedia.

I myself joined Wikipedia last November, and while I haven't been able to contribute as much as I'd like to due to the intensive studying I've been doing this year (hence the reason why my last post is from September 2025), I've been trying to contribute however I can in my free time, since I believe that is more beneficial both for me and for the greater good than doomscrolling. From when I joined until now, I have spotted a grand total of two articles heavily impacted by LLM editing: one nonsensical article and one attempted LLM rewrite of another one.

The case of the Washington–Moscow–Berlin Axis

As of the writing of this article, if you take a look at my talk page on Wikipedia, you may notice a comment from a user called "Africamatters", about their "Newest article (Washington–Moscow–Berlin Axis)". That article was the first (and currently only) article for which I started an AfD (Articles for Deletion) discussion.

This article first came to my attention in an attempt to find the German-Soviet Axis page or something similar by typing something along those lines on Wikipedia's search bar, when an article titled "Washington–Moscow–Berlin Axis" appeared. Upon clicking it, I was almost certain that it was the result of LLM hallucinations (the article has since been deleted but can be found in the Wayback Machine here). You can check my findings on the AfD proposal, from which it is apparent (as other users said), that the article is "entirely made up nonsense" (two speedt deletes) and that the article author's "prose is significantly different from the prose that existed in the article when they created it. The simplest explanation is that the article was created with an LLM".

Slavery in Africa

When I stumbled upon that article, I found it in a pretty bad shape: all headings were heavily capitalized, in some areas of the article there was bolding for no good reason, there were issues with named references and incorrect ISBNs, etc. At the time, I didn't have the time to clean up the article, so I just added a template to mark the article as needing cleanup. I didn't have the time to take further action, since another editor reverted the edits with the LLM-generated text, one of which was a +1k character addition within the span of 6 minutes from a previous edit, from a mobile device (I myself can't write 1k characters within 6 minutes on a mobile device. If you do, please let me know how, I'd love to know how to do it).

Bottom line

I keep hearing about the supposed advantages of artificial intelligence: that no one will write real code, that we won't need doctors, that it will cause an economic boom, that...

In reality, dealing with AI-slop is wasting people's time. Apart from my case with gitcredits, there seems to be quite an issue on Wikipedia, otherwise I don't imagine there would have been all this hastle with the RfC banning LLM-generated content. AI is misleading people, killing children in coordinated strikes and making RAM almost unaffordable, just to name a few.

I have seen what AI (not LLMs) can do, especially in the machine learning field. I participated in my country's IOAI selection phase (I didn't make it to the international Olympiad, but I got in the top 25% of everyone in the last national selection phase) and they used some pretty good and interesting examples for what AI can do: diagnose breast cancer, recognize deepfakes, and all those with a fairly good correct prediction rate, considering the fact that all the models we run were trained on Google Colab and were publicly available.

AI is an amazing technology, perhaps the most amazing to come after the invention of the Internet. We must realize that it can much more things than vibe-coding and filling the Internet with slop, or we will miss its true potential.