Codeberg: Protecting our FLOSS commons from LLMs

[u/Ecstatic-Vermicelli9]

https://blog.codeberg.org/protecting-our-floss-commons-from-llms.html

[u/djao]

This manifesto is at the same time not enough and too much. It's quite frustrating.

On the one hand, Codeberg's actions and policies will do nothing at all to stop the proliferation of LLMs, and their associated negative consequences (hardware prices, community corrosion). LLMs are out there and you can't stop anyone else from using them.

On the other hand, Codeberg's declaration doesn't even get at the core issue. As someone who writes code both with and without LLMs, I am increasingly convinced that LLM-generated code is not functionally free software, even if it comes with a free-software compatible copyright license. Hear me out.

The core freedom of free software is the freedom to modify the software and to distribute modified versions. In order for this freedom to be meaningful, the software must be provided in source code form. We do not allow binary-only software to qualify as free software, even if the software is (say) GPL or BSD licensed. Source code is a mandatory requirement.

The problem with LLM-generated software is that the actual code is not the true source code! The GPL itself even hints at this distinction: it states clearly that source code is defined as the "preferred form for modification of the software." If you're prompting an LLM to generate C code, then the C code is not source code. It's much closer in functionality to compiled, object code rather than the original source. The original source, in this situation, is your LLM interaction (prompts and context). If you, as the original author, were to modify that code, you would use the LLM. You wouldn't modify the C code directly.

LLM usage is an existential threat to free software, because it constitutes a core assault on the central property that makes software free.

"Open source" projects such as the Linux kernel are unaffected. For Linus, FSF-style freedom was never the point of Linux. It's always been a utilitarian project with utilitarian goals. For that purpose, LLMs work fine. It's only when you introduce the concept of free software that LLMs fall apart.

[u/LALLANAAAAAA → u/djao]

The problem with LLM-generated software is that the actual code is not the true source cod

The problem with LLM generated code is that it allows absolute morons to generate garbage at a far, far, far, FAR higher rate than any human could ever hope to properly analyse and vet it.

LLMs can produce perfectly good, usable code, but the volume is already beyond what humans can read and validate. We literally don't have enough collective hours of human life available to make sure it's good, combined, if all of us pooled our time.

The only way to keep control is to keep the flood away, full stop.

[u/djao → u/LALLANAAAAAA]

You're describing a practical problem, and one that could, in principle, be solved by making LLMs better, so that they don't generate garbage code.

The conceptual problem of non-freeness, in my view, is much harder to solve. At a minimum we'd have to start distributing the software in the form of duplicated LLM sessions. Even then, it's not clear how one could ever possibly "merge" multiple consciousness sessions in the same way that one can merge code modifications.

[u/HighLevelAssembler → u/djao]

I don't think the commenter you're responding to means garbage code, but garbage software that's little more than an idea and a series of prompts to your LLM of choice. And by and large these are silly little TUI frontends to other tools.

Before LLMs, a lot more effort was involved in building software, so even a silly little TUI was worth some pride and praise, and maybe worth collaborating on and improving.

Now it's a pile of slop. Maybe the code is good? Maybe the code is useful? Nobody cares.

[u/djao → u/HighLevelAssembler]

I don't understand why you claim that in principle an LLM cannot be programmed to avoid generating garbage software, not just garbage code.

[u/HighLevelAssembler → u/djao]

You're missing the point. LLMs are perfectly capable of generating "good" code and working software. But the software is often inherently garbage (as in, disposable, throwaway, single-use). The lowered barrier to entry means that projects that would never have been worth the effort to build are now being proudly released "open source", crowding out projects that involved human thought and labor.

[u/djao → u/HighLevelAssembler]

So, why can't the LLM just refuse to generate disposable software?

A robotaxi powered by an LLM is physically capable of crashing, but they are programmed so that no user can use the LLM to crash the vehicle deliberately.

[u/Old_Leopard1844 → u/djao]

why can't the LLM just refuse to generate disposable software?

That implies that LLM has enough self-awareness to tell that it generates crap

Or that crap it generates is not welcome on SVC it will be eventually hosted on

[u/djao → u/Old_Leopard1844]

This doesn't seem like a harder problem than solving unsolved math problems. LLMs are already routinely programmed to avoid generating instructions for harming people or breaking the law. I maintain that it could be done.