Free software people: A major goal of free software is for individuals to be able to cause software to behave in the way they want it to
LLMs: (enable that)
Free software people: Oh no not like that

When I write code I am turning a creative idea into a mechanical embodiment of that idea. I am not creating beauty. Every line of code I write is a copy of another line of code I've read somewhere before, lightly modified to meet my needs. My code is not intended to evoke emotion. It does not change people think about the world. The idea→code pipeline in my head is not obviously distinguishable from the prompt->code process in an LLM

Look, coders, we are not writers. There's no way to turn "increment this variable" into life changing prose. The creativity exists outside the code. It always has done and it always will do. Let it go.

(Yes ok there are cases where code is beauty and embodies an idea that could make a grown man cry and:

(1) your code is not that code
(2) you would think nothing of copying the creative aspect of that code if you needed to don't fucking lie to me)

Personally I'm not going to literally copy code from a codebase under an incompatible license because that is what the law says, but have I read proprietary code and learned the underlying creative aspect and then written new code that embodies it? Yes! Anyone claiming otherwise is lying!

@mjg59

The problems with LLMs aren't that people can ask them to write software.

It's that they write something that looks like software. They have no semantic model of it.

And it's that people think they can do away with expertise and experience (and salaries).

Then there's the massive environmental and social damage they are causing.

@mjg59 One difference I see is that when I implement (myself, with my own limited brain) my idea (or somebody else's idea for that matter), I actually learn something about the said idea, it becomes more precise in my head. Also, it makes me have other ideas.

@mjg59 it is not art, but at least it is craft and skill. And both should be honored. LLM Code is the assemble yourself cardboard filled furniture of codecraft. It is cheaper and faster available but what you safe in price you lack in quality.

@mjg59 This doesn't feel right to me. IMO few people actually object to use of LLMs by individuals for tinkering on personal stuff.

The criticism as I see it is primarily that:
1) there are huge societal/political impacts - uncompensated use of copyrighted material; benefits of it accruing primarily to a few big players; energy use; layoffs; perceived misallocation of massive amounts of capital
2) the output quality of LLMs is t r a s h, unsuitable for professional use

@mjg59
there is a difference between writing code and software engineering

writing code requires no understanding or decision making abilities, the attitude is "if it works it works" even if it doesn't work because you don't know enough to realize there is a problem

when an engineer makes something, they make decisions and evaluate those decisions based on their knowledge and experience

I value the engineering, I see no value in someone wrangling an LLM

@mjg59 Perhaps, but anyone claiming an LLM has "learned the underlying creative aspect" is also lying.

@mjg59 So the big thing is that all art belongs to society. To promote creation, society grants limited exclusivity, mostly to fund the work.

This means that, in a utopia, copyright wouldn't exist because everyone could stand on everyone else's shoulders.

The biggest problem is the tail wagging the dog. It's not about promoting creation. It's about giving power plays in the game of life to a selected few. That's literally oppression.

@mjg59 this feels like a weird reduction of the argument as LLMs as used by people do more than generate code at a micro-level (statements et al, regardless of your thinking those can't be creative), they are also used to architect codebases entirely

regardless, disappointing to read your apparent need to defend slop

@mjg59 thankfully there are plenty of other reasons to dispise LLMs, so we don’t really have to have this discussion :)

@mjg59 I agree not all code is art, and often not even craft. But contrary to optimizing compilers, we're not yet at a point where the generated code only needs to be read/modified by a handful of optimization experts, as it is with ASM. The generated code isn't even reliably identical between 2 prompts.

The AIGen'd code I've seen can be quite elegant taken in isolation, but looks a lot like a Frankenstein'd behemoth when I look at "large" (beyond toy project) code bases.

@mjg59 Yeah, as soon as there‘s an ethically sourced and trained free LLM that‘s not controlled by very shitty companies I‘m totally on board with you.

Until then we shouldn’t let that shit near our projects.

@chris_evelyn That is a coherent position that I have no fundamental disagreement with

@mjg59 Fuck off with that shit. This doesn't even smell like a good faith argument.

@mjg59 Weird view of writers as a group you are expressing here, in order to make this distinction.

Code isn't there to be art, sure. It is there to communicate, though. Making this some weird thing about art, as if that's the only reason software developers might not want LLM generated code in their code bases, is… disingenuous to say the least.

@mjg59 I agree with this last statement 😁

@mjg59 I disagree. Code is written for people, not computers. It doesn’t matter where the creativity exists, if companies/people reap it without giving a damn.

“Let it go!” == “Don’t fight it!”

@mjg59 IIRC a big confusion was that early on Copilot would generate verbatim copies of existing, GPL'ed code, including comments. I do neither understand why that was the case or if that has changed, but my understanding of other LLMs is that they don't work in a way that they are just literally reproducing existing input.

I think you are right in pointing out that writing code is not really a artistic/creative job, no matter what we have been saying to ourselves.

@mjg59 What you propose is actually illegal, even if the law doesn’t make much sense. I wonder if you ever had the cops sent after you on a corp-run IP case… maybe it would make you feel different?

@tthbaltazar I agree with your distinction, and also both outcomes can involve me either writing by hand or engaging sufficiently clearly with an LLM to get that outcome.

But, well, we all know software engineering isn't what we all engage in. Sometimes we just want to fix a thing and we don't want to write tests and we don't want it to be perfect and there's value in that!

@mjg59 @tthbaltazar might i suggest you not compare that to software engineering then?

@mjg59 Ok, but the process of writing code is creative. You think as you write, new ideas are formed. The LLM process at least reduces that.

@radex See I fundamentally don't believe that code should be copyrightable and also me 30 years ago did not produce code that was suitable for professional use but it fixed my problems anyway

@mjg59

Enablement isn't my issue with use of llm's. It's the glossing over of it's downsides

the techbros pushing it & the bullshit claims made for what it can do
the price paid by the ppl who provided the data sets
the environmental impact of the data centres
the users the techbros sell it to
the anti freedom uses it gets put to
the fact the shit code it produces from poor programmers - wanna fly in a vibe coded plane?
the loss of skills when you rely on llm's 100% of the time

@Nfoonf If you're willing to accept that then what's the problem? Are we threatening to burn down Ikea stores now?

@exfalsoquodlibet Personally I'm never going to put shit into the code cranking machine unless I have an extremely good idea of what's coming out the other end and if it surprises me I'm going to learn from that, but I don't think that's a reasonable thing to insist that everyone who wants their code to work should do

@dekkzz78 There's truth in what you're saying and also a lot of it is the same shape as arguing against mass produced clothing over hand tailored clothing

Clearly my most unpopular thread ever, so let me add a clarification: submitting LLM generated code you don't understand to an upstream project is absolute bullshit and you should never do that. Having an LLM turn an existing codebase into something that meets your local needs? Do it. The code may be awful, it may break stuff you don't care about, and that's what all my early patches to free software looked like. It's ok to solve your problem locally.

@mjg59

@barnoid Huh interesting, that's really not my experience of writing code - I sit down with a formed idea of what needs to happen and then I smash keys until it's there. And now I'm curious whether there's a real disconnect between with different models of coding.

@promovicz Information wants to be free

@mjg59 That being said, I do think that the "Free Software" concern is legitimate, especially when people are replicating existing GPL programs to circumvent copyleft and undermining a sense of community. After all, copyleft means that you are publishing the source of a program, thereby respecting the user, under the condition that they return the same respect and treat everyone else under the same terms.

@pkal In a universe where someone could legally say "I want software that does this, but slightly differently" and get it then copyleft would be meaningless - the free software goals would already be achieved

@shiz Plenty of ways you can use this to generate terrible outcomes, and also plenty of ways people can hack shit into copyleft code that results in terrible outcomes, we can't copyright license our way to taste

@promovicz Man in an ideal world sure, but in the world we live in people frequently write code for themselves and not others. How many projects have weird macros or unhelpful comments or quirky norms? To the extent that code is creative it frequently hinders understnding and reuse, not aids it.

@mjg59 it is absolutely wild to see self-described free software enthusiasts cheerfully be on the same side of copyright maximalism as Disney, RIAA and MPA

@barubary given my history, if your immediate conclusion is that I'm not presenting an honest opinion then I think you have a fundamental misunderstanding of who I am

@jenesuispasgoth I mean kind of the point of free software is that people get to modify it to their own ends and that doesn't mean it has to be good - when I first started hacking things to meet my needs I was definitely writing stuff that couldn't be upstreamed, but it worked for me, and making it easier for others to do that is a win

@mjg59 sorry, last one I promise

EDIT: since in this timeline we can't have nice things, I'm told the tug-of-war comic author is an absolute tosser, so dropped the meme. Originally it was the meme with foss devs using llms and microsoft on the "all software must be free" side, and free software activists and disney/riaa/mpa on the "copyright maximalism" side

@dysfun @tthbaltazar Where did I do that?

@p If you're doing something other than

var++

then you're doing something wrong. Code is instructions to a machine. The description of what that code does may be creative, if the actual implementation is then you are almost certainly in a bad place.

@mjg59 the problem ist the expansive nature of low quality capitalism and the vulnerability of craftmanship to industrial mass production. One day you only can get the low class slop and the many ways in which it hurts people due to it‘s shortcomings will be normalized. And we lose craft and skill in the way that will not be replaced but has to be bought from the rent seeking owners of the factories of low class goods. Of course people of wealth will not see this as a problem.

@mjg59 you can probably buy yourself free from the misery of the shortcomings of low quality goods and services.

@Nfoonf Back in the day I had software that didn't do what I wanted, and I didn't know C yet. I patched stuff in many awful ways that met my needs and which taught me nothing in the moment and could never be upstreamed. How would having a machine help me achieve that make free software worse?

@mjg59 so LLM slop is probably once again a class problem and as it not only keeps people from getting better quality goods but also denies people knowing certain skills of earning their livelihood by offering these low quality solutions you can not possibly compete with.

@mjg59

I’ve heard this argument before and I disagree with it. My goal for Free Software is to enable users, but that requires users have agency. Users being able to modify code to do what they want? Great! Users being given a black box that will modify their code in a way that might do what they want but will fail in unpredictable ways, without giving them any mechanism to build a mental model of those failure modes? Terrible!

I am not a carpenter but I have an electric screwdriver. It’s great. It lets me turn screws with much less effort than a manual one. There are a bunch of places where it doesn’t work, but that’s fine, I can understand those and use the harder-to-use tool in places where it won’t work. I can build a mental model of when not to use it and why it doesn’t work and how it will fail. I love building the software equivalent of this, things that let end users change code in ways I didn’t anticipate.

But LLM coding is not like this. It’s like a nail gun that has a 1% chance of firing backwards. 99% of the time, it’s much easier than using a hammer. 1% of the time you lose an eye. And you have no way of knowing which it will be. The same prompt, given to the same model, two days in a row, may give you a program that does what you want one time and a program that looks like it does what you want but silently corrupts your data the next time.

That’s not empowering users, that’s removing agency from users. Tools that empower users are ones that make it easy for users to build a (nicely abstracted, ignoring details that are irrelevant to them) mental model of how the system works and therefor the ability to change it in precise ways. Tools that remove agency from users take their ability to reason about how systems work and how to effect precise change.

I have zero interest in enabling tools that remove agency from users.

@Nfoonf The irony here is that now I have money I would rather pay people to solve these problems

@mjg59

true, but then its down to values & how you prioritise such things

wrt coding specifically companies are worried about skill loss & being dependant plus it ties the seniors into code review all the time

also I know 2 auto companies that have banned them due to creep into safety critical code

@mjg59

plus mass produced clothing wont cause a plane to drop out of the sky

@dekkzz78 I am absolutely not going to argue that LLMs replace the need for skilled developers! But many people who want to modify software are just doing it for personal use and if we argue using LLMs for that is unethical we risk alienating them all

@mjg59 @dekkzz78 People who have decided that they don't need to learn how to program are not people whose recycled code I want in my projects or on my computers.

@dekkzz78 Safety critical and security critical software should always have an appropriately skilled human in the loop

@mjg59 no amount of prompt clarity is going to get you a correct/"according to spec" outcome; LLMs are categorically incapable of that

@mjg59 heh, one of the new ideas in a project I'm doing virtualization work for is to have a fully local LLM generate bespoke apps and instantly summon them directly on the desktop.

I don't think current local LLMs are actually "ethical" either, all my "fuck that entire industry" concerns are always present, and personally I wouldn't like using straight up fuzzy statistically magically inferred apps at all. But I do like the idea of empowering people to locally just do bespoke things like that, as long as there's always a big disclaimer about it being made that way and so on.

@david_chisnall @mjg59 @ignaloidas llms can be used to explain and learn things. Unsurprisingly, that’s what many people do when things don’t work, be they written by a human or not, and they want them to work.

@mnl @mjg59 @ignaloidas

And they will give entirely plausible explanations. Occasionally, by coincidence, they will be correct.

@dngrs sure! Define smaller blocks, examine them, modify if the output isn't what you need

@david_chisnall @mjg59 @ignaloidas just like humans! Or books!

@mnl @mjg59 @ignaloidas

Not even close. Humans build mental models of things and, if correct in one area, are likely to be correct in adjacent ones. And, in most cases, are able to say ‘I don’t know” when they don’t know the answer. Books (at least, those from reputable publishers) are reviewed by technical reviewers who spot factual errors, and have finite contents and so will simply not contain an answer if it is not something the author thought to write.

LLMs will interpolate over an n-dimensional latent space to provide a convincing answer. That answer may, if those bits of the latent space were well populated by things in the training set, be correct. But there is no difference from an LLM’s perspective between a correct and incorrect answer, only a likely and unlikely one.

@mjg59 I completely agree, but I'd add a couple of things... if you understand the code, then LLMs are just providing acceleration to your efforts. Also, solving problems locally for yourself is great, but there's no reason why you shouldn't share the solution in case it helps someone else. Just be transparent about the possible quality concerns.

@mjg59 But, why does that matter? Copyright protection does not depend on quality, usability or popularity. Bad art is protected. Even mainstream pop is protected, and whether its reuse is any good is kinda off-topic.

As a hacker I can also believe in a lot of "copyleft" ideas, but either way these concepts are there to protect a social (and maybe legal) balance. You end up co-arguing a "might makes right" perspective, and risk devolving into fascism.

@mjg59 posting this on Mastodon.. looking for Friday night entertainment 😂

@promovicz I think a set of instructions to a machine should not be copyrightable and the rest flows from there.

@bluca I do see your point and also please do not post Stonetoss at me

@bluca (The original version of this is pretty anti-semitic and the author is a fucking nazi)

@mjg59 yeah sorry I had no idea, already deleted earlier as someone else told me

@mjg59 I have also had the retained knowledge concept explained to me by a lawyer back in the days when I used to work with proprietary code bases 😅 I wonder how quickly the various test cases will work their way through the courts before the LLM situation is clearer. They are doing the same things as us humans but are able to do it with much better recall.

@chris_evelyn

It's my belief that Mistral's models fit that bill.

@mjg59

@troed @chris_evelyn @mjg59 last time I checked, Mistral models were merely open weight, with no training dataset available nor training pipeline released as FOSS. Has that changed?

@mjg59 hey, I'm all for laundering IP, I just need to make sure it launders propiretary IP as well as open-source!

@mjg59 I think the negativity comes from the fact that a lot of floss developers have other reasons why they work on projects besides scratching their own itch - "meeting the local needs" as you put it.

That is expanding their knowledge and, sometimes even the enjoyment of the programming act itself.

So if you treat open source development as a learning experience and an artistic expression, you're automatically going to balk at something that would take that away.

@david_chisnall @mjg59 I suspect CHERI would make running LLM-generated code more feasible, and probably less risky. I'm not saying this to be an annoying contrarian, but rather that stronger underlying models seems to make playing with garbage LLM code more viable. Terry Tao has been using them to generate quick and dirty proofs, cha bu duo.

@mjg59 i think the submitting it back is the part people are angry about not that it is possible

@mjg59 The LLM-hate reminds me of the backlash against computers themselves. People insisted they were 100% worthless because someone got a bill for $0, and then a notice they were in arrears when it was not paid. Many projects either failed outright or people had to do their work twice, first the old pen and paper way which worked, and then also put it into the computer never to be seen again...

@zacchiro I understood the ask I replied to was regarding ethical training. Mistral, as an EU company, has to abide by EU regulations AI companies in the US, China etc don't have to.

https://artificialintelligenceact.eu/article/53/

@chris_evelyn @mjg59

@mjg59

They do speak of 'elegance' even 'beauty' when it comes to mathematical proofs.

Aesthetics are not a positivist axiology. Beauty is famously in the eye of the beholder.

Just because you are aware you write ugly code doesn't mean code cannot be beautiful, or that aesthetics are not a legitimate field of assessing information systems.

@mjg59 No, I do think you're being honest, I just think your opinion is kinda bad.

@mjg59 You never realise the original idea could be improved a bit along the way? This probably depends on what's being worked on. Most of the stuff I do is fairly small scale and not particularly well specified (day job is mostly sysadmin, off day jobs are museum installations).

@mjg59 you might be missing a few of people's issues with LLMs. Our programmer standpoint is quite niche.

What happens to people with jobs that are affected by LLMs? They either start using LLMs to match the competition's performance, or get obsoleted... What if they can't actually afford using LLMs to stay competitive?...

And then there's art.

On top of all of that LLMs are energy and resource-hungry, ruining the environment and making everything more expensive...

@mjg59 Funny one, but you forgot the most important of code. It's a tool for human understanding. Statistics can *probably* find some common pattern, but it have nothing to do with "understanding".

@mjg59 I somewhat agree, but I would like to extend this idea even further: current copyright laws cover software. copyright was meant to protect creative pursuits, which code (as you put it) is not. Many other technical fields don't have a copyright either. Let's abolish the software copyrights that so much of big tech profits from.

@mjg59 That's an unrealistic example. My piano playing is MUCH worse than the code I used to write.

@mjg59 "sure" as in you're agreeing or disagreeing with me?

@mjg59 This might be the dumbest thing you have written. You basically just said anyone who claims not to have committed copyright infringement is lying, which is both obviously false and insulting to developers.

@mjg59 but you are paying the owner of the machine a recurring rent, aren't you? does this not bother you? what this machine does for you will never be yours, you will pay them again and again. you do not own the tools of your trade anymore. If the rent seeking owner denies you access or you can not afford it anymore this is all gone.

@mjg59 " Every line of code I write is a copy of another line of code I've read somewhere before." This cannot possibly be true. Surely you've written some original content, as a developer, which was unique or which created your own function, or did something you hadn't simply read before?

Even if it is somehow true for you, it is not at all how most developers write code.

@mjg59 Since you don't want to talk about the human/social side, you can only miss it.

@mjg59 heh, poked the bear with this one.

unfortunately most computer users are also not set up in a way where a subtle piece of malware injected into a python script or something could ruin their day.

tao uses them for generating proofs, which seems to work, and I have had some use to similar ends. they're quite bad if you have any delay in your feedback loop though

@mjg59 @jenesuispasgoth
There are people that analyse, design and then implement as code. Those are programmers. LLM can't replace that,
If you only ever tweak someone else's design, you may not have learned to program, only learned a language, or framework or library APIs. So maybe an LLM might help, because it's a plagiarism machine. It ignores licences and the companies building them (so called "training" = copying) have violated IP, copyright, copyleft/GPL etc on a massive scale. Theft.

@mjg59 @p
You don't understand IP/Copyright or maybe even actual programming, of which actual coding or editing code should be a minority of the effort.

You're simply promoting theft for the sake of convenience. The USA & China companies are simply ignoring the laws in their training.

@mjg59 Most of the discourse just shows why "the Linux community" is considered this elitist toxic cesspit by most non linux people people

And it's wild, because many that consider them the good folks in this regard are also participating in this toxicity

it's like being condescending and shaming others for their poor choices is seen as the normal thing to do

@mjg59 you mean "not by paying monthly $200 to a wanna be megacorp"? Yeah, not like that indeed.

13 years old me started coding on an old Windows 3.1 workstation with ~$0 monthly cost. If I were to enter the industry now, when one has to invest in LLMs, which btw also prevent from gaining actual skills and erode existing skills, I would simply have not done that. Must be why genZ hates LLMs

I don't see how one can look at the thought-extruding machine and think "surely it will liberate me"

@mjg59 pretty much. I deeply dislike any PRs I see on various projects where the prompt was basically just something like "I want you to implement this major feature into this project", with no real understanding of the underlying code and whatnot.

I would rather have coders that know what they're doing and that understand their codebases use LLMs than a random Joe Schmoe like those TikTok vibecoders with like 5 monitor screens, brainrotted on short-form content asking Claude to add E2EE to some project or to refactor the rendering process of a game engine or whatnot.

These people are wasting the maintainers' time with a jumbled mess of AI code that assumes a few things and that likely breaks on the first try.

---

There's nothing wrong with pulling a git repo and then vibe-coding a quick thing as a test or for your specific use case, but there's everything wrong with upstreaming that as a PR if you have no idea how the project's code even works or how it's architected, and with no tests or checks.

@mjg59 this may be true for code I don't care about or need to deliver quickly, everything else definitely contains as much beauty as I am capable of

@bananarama @mjg59

It certainly can. As long as you are careful about the interfaces to the compartment, you can reason about the worst that can happen with the LLM-generated code. I see this as a special case of supply-chain attacks, which the CHERIoT compartmentalisation mode was designed to protect against: assume this code works for your test vectors and might be actively malicious in other cases, what's the worst that can happen? LLM's just let you bring the supply-chain attacks in house.

@mjg59 "i don't like programming and anyone who does is a liar" is a hill to die on, i guess

@troed I see. I don't know either what @chris_evelyn had in mind, so I'll leave it to them. But for what is worth the EU AI Act equally applies to all companies having access to the EU market. Mistral is not be special in that respect, unless the other players decide to leave the EU market (which is unlikely). @mjg59

@mjg59

This is such a bullshit, deprecating framing of what developers do. The fact that you also deprecate yourself doesn't make it any better.

Sure, the individual "line of code" may not be very unique. But the arrangement of many lines is. Your comparison is about equivalent to saying "hah, how can an author produce anything novel if he's just using the same old words from the English alphabet!"

@mjg59 I have some issues about using LLM, but the only one in the free software world is about license tainting: I’m not sure if the code generated by a LLM is public domain.

@mjg59 I think this understanding of art stems from a misunderstanding what art in itself is.

Like of course writing code can be an artistic activity and trying to argue against is just shows a deep misunderstanding of those who see it that way.

But "arts goal" isn't even to be life changing prose, most arts goal isn't even that at all. Most "classical" art was even seen as "just a craft".

"beauty" can manifest in many ways, and self-expression through code is a thing.

@mjg59 You will get backlash, but you are right.

Free software folks will have to decide whether what they really wanted was *everyone* to have the freedom to use and modify software, or only that subset of everyone who had the privilege of learning software development.

There has always been this elitist dividing line in the community between people who contribute code, and people who contribute all the other things FOSS needs to thrive. Now those people can contribute code too.

@mjg59 I'm all about running very outdated software on slightly less outdated Hardware. That's the good stuff bro.

@mjg59 Learning from and adapting ideas from unlicensed code into new code is an accommodation under law for humans. If you built a machine to do this at scale, however, that's a choice to leverage a humane decision into a profitable hack.

@mjg59
LLMs able to produce software are neither free in cost nor in freedom as today, which would be OK as a temporary step but not as a long term solution, a free LLM where the source data would be free and an individual could retrain it independently could be a solution but as today there is no technical solution aviable for not millionaire individuals

@kyle @mjg59 Proprietary tooling is the reason "Stallman was right" about Bitkeeper, but "everyone was better off for having not listened to him" is the pragmatic side.
Yes, I want people to benefit from the freedom to modify code, but they will never truly be free if they are using a proprietary LLM to make their modifications.

@mjg59 LLMs do not enable that at all tho? an LLM enables people to make software behave as they wish similarly to a crowbar enabling people to open a door

@mjg59 I think the issue is more on the forcing of LLMs/AI in *everything* right now, not specifically F/OSS projects. It reeks of dot-com bubble era marketing and in many cases is completely unnecessary.

@mjg59 but wait, there's more

What if you're not renowned security expert and open-source celebrity @mjg59 (that currently works at nvidia btw, profiting from the LLM boom, sorry) but just some guy trying to make ends meet doing some coding?...

Now you get an LLM mandate from your company that comes with the implication that 'either you boost your productivity with 80% or we fire you and contract a cheap prompter in your place'...

@petko @mjg59 You can see that there’s no care for any of that. It’s all “like LLMs? Good, go use it, it’s fun”. All your ethical believes go out of the window as soon as your company shares depend on the hype.

@mjg59 Indeed.

This is why code generation is not a solution to the problem.

Which problem? People will phrase it differently, but the basic idea is to outsource *the hard part*, which is analysis and phrasing requirements to guide the LLM.

LLMs suck at dealing with shitty specs. They even suck at dealing with good specs. They even suck at dealing with specs they themselves suggested.

https://finkhaeuser.de/2026-04-10-outsourcing-thought-is-going-great/

So using LLMs isn't solving the problem, which is that thinking is hard.

@mjg59 you’re doing the thing where you’re romanticizing another profession by assuming the grass is greener. most writers are not novelists. most are writing pretty dry ad copy or instruction manuals or something, just like most programmers aren’t writing especially novel or beautiful algorithms (or, for that matter, video games where algorithmic processes evoke a feeling). you’re just confusing form and content here

@mjg59 and yeah, “not like that” is actually valid, it’s just “having standards”, when “like that” is plagiaristic and error-prone and unsustainable and ecologically damaging on a world-historic scale. you don’t have to cancel every ethical principle you have so you can make a button a color you like better, even if you don’t really know how to code. you can argue that this ethical calculus is *wrong* but it is very silly indeed to pretend it’s contradictory gibberish

@mjg59

if i am honest the price of such, psychotic breaks, isn't worth the freedom of per request billing

@mjg59 I don't think your points in this thread are wrong, but I'm going to gently, firmly disagree with you about the universality of your statements.

I program for many reasons, but a core reason why I enjoy it so much is that I learn new things about the problem space during the process. I treasure that. I go back to restructure my code after it works to try to share this process of discovery & learning with folks who might read my code later.

LLM coding for effect only ignores this.

1/2

@mjg59 I'm not opposed to the existence of code-for-effect, and I'm not even opposed to using such software, but it's not what I want, care about, or treasure. I treasure code written for readers and contributors first.

I want there to be more of this kind of code in the world. And I don't think it's a zero-sum game: there can be more rich code _and_ more code-for-effect. They're both fine.

I just don't think I'm OK with the statement that code-for-effect is the only kind that matters.

2/2

@mjg59 @barnoid Yes, a lot of people do programming as an art/craft. That's part of why it's something some people *enjoy* doing. Like me.

> I sit down with a formed idea of what needs to happen and then I smash keys until it's there.

This explains your disconnect very well.

@david_chisnall @mjg59 I don't think AI is ready to empower non-programmers to build whatever they want... yet. I think they might have the potential to do so in the future, though, as the technology improves.

@mjg59 Yeh I agree; I think some people only saw LLMs maybe 3 years ago and they were pretty stupid at the time just regurgitating junk and haven't noticed the modern stuff is actually understanding the code in some cases; well, at least as well as an intern and frequently better.

@mjg59 years of reputation thrown away on a single thread: a masterclass

@mjg59 But why would LLM trash solve ANY need, locally or globally, Matthew? That's the real question.

Your opinion on this matter honestly ought to be discarded without consideration: you have a naked conflict of interest in plain sight, corrupting your judgment. Your livelihood depends upon #Nvidia and its dedication to corrupting all of computing with LLM gibberish (and, in the process, turning all software into mere tools of corporate surveillance.)

@mjg59

for personal use i won't argue but there should be localised agents that don't need the datacenters that cause so much damage.

maybe one day there will be an #emacs package trained with known ethically created FOSS datasets for the language of choice

@mjg59

phew, not sure (!!!)

What if the variable is a cursor in Marx Capital or Orwell 1984?
Or both?

And what would Jesus have done?

@mjg59 @radex Interesting!

@mjg59

its all to easy to taint known good code, on sharepoint now everything has sprouted a co-pilot button tagged as "made available by your org tech team"

a totally false statement that suggest your employer wants you to use it

that's why all the programmers had an all hands teams telling them in no uncertain terms no AI code was to be created & would be deemed as instant dismissal offence

@mjg59
> Having an LLM turn an existing codebase into something that meets your local needs

... Is a great to way to introduce hallucinated library names into your code, that can be squatted by people distributing malware. Even for this, running code vomited up by a Trained MOLE is self-punching. Using its shitty, broken code as a source of serendipity, to help you find new ways to solve a problem in your own code, ok, *maybe*.

@dekkzz78 I agree that there are excellent reasons to prefer hand written code under an extremely wide range of circumstances

@dngrs Agreeing - if you want high quality implementation of a spec there's going to be meaningful human involvement in the process

@mjg59 strictly local needs, you do you.

If using a giant model like Claude, you might want to consider what remodelling that code will cost the planet in terms of direct carbon output, electricity generation, water pollution, amortised environmental cost of building the Pollution Centres and the ongoing damage to local communities of the Pollution Centres.

If you can live with all that? Sure, use your magic auto complete. Just don't expect others to not judge you for it. Not saying I would, btw, but that's the argument .

@dgold No disagreement whatsoever

@mariusor I should be clear that I write code by hand and enjoy the process, and also agree that the only way you're going to get high quality human developers is through doing that. But I also think that the world is probably better if more people are able to modify code to meet their needs, even if those people never turn into high quality human developers as a result.

@MrBerard I agree that code *can* be beautiful, but the overwhelming majority of it is not in a way that is very distinct from, say, literature, where even the most churned out boilerplate nonsense still embodies some level of emotion

@RogerBW @dekkzz78 We're on the same side there.

@barubary Disagreement, I understand - accusation that it's not a good faith argument, I don't

@barnoid Oh yeah, frequently - but the same happens when I'm in the shower or walking to the station. It's the act of thinking about the problem that does it for me, which is kind of incidental to the act of coding.

@petko Yes, I think there's a large number of extremely bad real world outcomes associated with LLMs

@strm I think widespread adoption of LLMs in the software industry is likely to result in an overall decrease in the quality of software and the quality of software developers

@Nfoonf Not inherently, no - local models can be run on reasonably affordable hardware, and produce acceptable outcomes.

@mjg59 yeah Matthew that's not a good one mate... Cya later.

@petko I think the widespread adoption of LLMs by industry is likely to reduce the quality of software and make it extremely difficult to maintain a pipeline of people who actually understand how software works, and I'm certainly not going to defend what's going on there

@raymaccarthy @jenesuispasgoth I'm not arguing that LLMs replace the need for humans who understand how code works, or that people who use them are becoming programmers in the process.

@raymaccarthy @p I am more familiar with both than I want to be

@mjg59 Everything I ever wrote in R4RS Scheme was poetry, and I'll hit anyone who says otherwise with a chair.

@lodurel If someone is interested in coding then they should learn to code! I am 100% in favour of artisinal handcrafted code and the process of learning how to create it. But there's plenty of people who don't have the desire or time to learn, and giving them a way to modify code to behave the way they want anyway seems good?

@distrowatch No, I didn't. Code is copyrightable, the underlying creative concept isn't, and reusing that concept isn't copyright infringement.

@distrowatch I come up with a creative concept of how a function should behave, and then I mechanically churn out the code that results in it doing so. The individual lines are fundamentally uninteresting, it's the first step in the process that's where the creativity happens.

@phooky I greatly enjoy programming! I enjoy figuring out how to solve a problem, I enjoy having that solution exist in the real world, the actual process of writing the code is pleasing. But the code itself feels like the least interesting part of that?

@luatic Let me try to express this differently. A literary work consists of both a plot and the work expressing that plot. Both of these are extremely creative - a mechanical implementation of a compelling plot has little value. For software, the concept and the logical structure are where almost all of the value is, the actual choice of words in the implementation is pretty uninteresting in comparison

@mjg59@nondeterministic.computer If you want to use LLMs to make a software what you want, feel free to do it in a private forks. Private forks for yourself are fine. Private is private.
But its also the freedom of the developer/maintainer of the software to not allow such changes upstream or force such changes to be marked.

@neintonine Agree

@bazkie A completely legitimate thing to do if all you care about is getting through the door

@glyph I think I've covered why the plagiarism bit feels less true to me for code than for other fields, and I don't think the error prone aspect of it matters for the cases I'm thinking of. The world burning and economic destruction and loss of human skills are certainly a consequence of how these things are currently deployed but it's not inherent (at least, not to anywhere near this scale), and having it be an immediate "no" rather than "Is there an ethical way to do this" feels rough

@glyph Mm, but when we talk about the ethical impact of LLMs it tends to be focused on how it impacts artists rather than the people doing wrote output (but I'd also argue that there is significant creativity in the actual writing of a good instruction manual in a way that isn't true of most code).

But maybe I haven't been clear. To me, the algorithm is the creative part of this, not the code that embodies the algorithm. But despite that, I'd have no ethical concerns about reimplementing it.

@rafaelmartins What's the point of reputation if not to be able to burn it

@mxchara The only LLM I use is a local model running on the Apple Silicon device on my desk, and it's been fun figuring out what it can do (more than I expected!). This kind of thing is going to be increasingly viable over time and is what I'm interested in in this respect. Can it take existing source code and add a new feature? Yes, and that seems like it would be helpful for people who don't know how to code! It's not how *I'd* approach the problem, and I don't see that changing.

@mjg59 it's therefore only natural that you'd think of writing code merely as a utilitarian matter of extruding whatever goo and dribble is sufficient to satisfy bare minimum internal requirements, whatever's just barely enough to pronounce that the goo is salable. Meanwhile the end user gets to endure software products that are getting ever worse by the year—more bloated, more unreliable, more dedicated solely to serving the corporate needs of the software's vendors (and whatever fashy police-state government entities they're dealing with under the table.)

@mjg59 you're a genetics Ph.D., Matthew? do you mind if I ask why you quit on science to chase after computer money?

@mxchara I'm better at computers than I am at science, and I spend a whole bunch of my time working on free software for no compensation so

@dekkzz78 A completely sensible position for a company to take

@andi Is it the actual code that's the art for you, or its structure? The algorithms it expresses? The functionality it implements? I'm genuinely curious here - I'm certainly open to the idea that I approach this differently to others

@mjg59 Well that's an answer! I'm not great at science either because my head doesn't cooperate, but I decided to go into the humanities instead.

I'm trying to sum up my objection to the LLM trend, once we attempt to separate the LLM from the thoroughly corrupt apparatus of corporate technology that's spawned the latest craze. I try to remember that the current crop of techbros didn't invent the LLM after all; as with all their faux innovations, they appropriated the LLM from earlier work. So let's assume for the moment that there was actually some value to the brute-force LLM technique, and you don't care that it's sold fraudulently as if it were superintelligent.

Here's what your proposing, as far as I can see: it's acceptable for someone who doesn't know how to code, to nevertheless contribute to developing software which you want other people to use (in other words, this ought not to be about yourself, but about the users upon whom you propose to inflict LLM-modified software) because you think that it's acceptable to contribute code that you didn't actually write, generated by a black box whose internal workings or technological context don't actually mean that much to you—because you care only about its output.

@mjg59 @lodurel there are glaring issues with LLMs surrounding ethics, among many other things (that you are agreeing with elsewhere in the thread!). therefore, the free software advocates are not going to be blindly pro-LLM. that’s how social movements work. those issues don’t disappear just because the technology makes life a little bit easier for some people

@epetousis @lodurel Oh yeah 100%

@mxchara Oh gosh no - I'm not proposing that at all. I'm saying that if someone who doesn't know how to code has software that doesn't do what they need it to do, an LLM would potentially allow them to change that.

I don't think anyone should ever contribute code they don't understand. I don't think anyone should ever encourage other people to run code they had a machine regurgitate without understanding it themselves. I don't think LLMs are the future of free software development.

@mjg59 @glyph But there are many possible implementations of a technique. How do you go about distinguishing between them or choosing one? Isn’t that creativity?

You could say any variation in the implementation that has mechanical consequences (I.e. not just syntax or style) means it’s a different algorithm, but then you would be acknowledging that the code itself matters.

I guess to an extent the concrete implementation *is* the algorithm?

@mjg59 it sounds unconvincing to me. the plagiarism thing has to do with sustainability, not just aesthetics. software errors tend to be chaotic and compounding and thus you’d need strong edges to the sandbox where the agents were allowed to play, which we don’t have. and the “inherent”-ness is a red herring. it doesn’t matter if there’s a *pretend* version of this tech that is ethical, the real-life version we have has the problems it has, and I haven’t heard any plausible way to separate them

@mjg59 but most of all you seem to be doing cartesian dualism here, where the “real” creativity is in the “system” not the “code”. but you can do that with prose, too? the sentences are mere words, nothing wrong with copying a word. no way to make someone weep with a punctuation mark, it’s the story where the creativity lies, not the words. and… sure? but there’s no transcendental essence outside of the mundane material components in either case

@mjg59 playing music is pleasing. is the instrument the least interesting part of it? is the score? are the brushstrokes the least interesting part of a painting? it depends what you're looking at, and what the artist enjoys. it's completely valid that you think that the code itself is boring, but understand that other people find different forms of value in the work they do, and none of these opinions are universal.

@glyph I understand your point and to me it does feel like there's a real difference that I'm not expressing terribly well. Words have a meaningful impact on how the story lands, and that just doesn't feel true for most code? In general I want code that clearly communicates the functional goal, not code that seeks to accentuate that through style.

@glyph There are certainly counterexamples, but they feel like notable instances rather than the common case

@mjg59 It's true that code has a functional aspect that prose doesn't, and the aesthetic nature of appreciating code is very different than how one appreciates prose (and is far less universal). I also agree that the counterexamples are extremely rare. But … good prose is also exceedingly rare, and LLMs can also produce prose just fine to achieve the utilitarian end of consuming a reader or a listener's time in a baseline pleasurable way. If not, there'd be no audience for shrimp jesus memes.

@mjg59 If we focus narrowly on the issue of producing the aesthetically pleasant code itself, without worrying about sustainability or the environment or the other 10,000 words worth of harms I just wrote about and the 10,000 more I probably have left to go in this monster post I'm working on, just for the sake of argument, let's say that the average coder hits a beautiful expressive algorithm 0.1% of the time, but an LLM hits it 0%. I think that 0.1% is load-bearing.

@mjg59 @glyph If half your code isn't prose -- which is to say comments -- then your code is, what's the word, bad.

@mjg59 I also think that stylistic flourishes qua style are also fairly hollow in both prose and code. Moving prose has long build-ups and parsimoniously executed pay-offs. Really good code has a codebase-wide harmonious nature to it, the most "beautiful" code is what I would describe as "structurally symmetric", not a little standalone diamond of an algorithm but a pervasive style throughout a codebase.

@glyph @mjg59 So, while I'm definitely concerned with the number of folks who have said "I'm never writing code by hand again", the existence of LLMs doesn't mean that no one will ever write code by hand again, and I think those folks who are likely to write that beautiful bit of code are also the types who will continue writing code by hand sometimes.

I don't necessarily think you're going to get 0% in a world where LLMs exist and people use them. Yeah, people are over-indexing in that direction, but I don't think that means that everyone will stop writing code by hand entirely.

Remember, the vast majority of code out there is "I'm grabbing data in this shape from this weird poorly specified REST API, and turning it into data in this other shape to shove it into this other poorly specified REST API".

There's not much creative about that kind of code, just a bunch of tedious "OK, let me try this and see if it works and then figure out if it doesn't that actually I need to include this field that was mentioned in a completely different section of the docs"

Like, I also find this whole thing aesthetically unpleasant, but I've seen a bunch of folks be able to get one REST API glued to another, or mash together a bunch of React components to make the dashboard that they want, or whatever, which is not in any way creative, just a bunch of tedious fiddling with some APIs which are full of tons of accidental complexity.

And yeah, I'm sitting here saying "well, we really should be working on getting rid of that accidental complexity", but in the meantime there are folks out there that now have a tool that will just grind through it and give them something that solves their problem.

@unlambda @mjg59 at this rate I'm never going to write code by hand again either, just progressively longer toots, articles and eventually books on aesthetics and meta-ethics

@jwz @mjg59 I feel like it would be cheating somehow to quote Abelson from SICP, but ultimately that is what we're angling toward, and as much as the sentiment may be trite it is nevertheless correct

@mjg59 @glyph Clean code is code that you can clearly read the intent of, and fundamentally LLMs don't have intent. They can approximate something communicative, and that accomplishes a goal, but it doesn't fit together the same way.

Also generally, do we want a lot of meh, random permutations of similar code in every individual project, or do we want better quality shared code?

@mjg59 @glyph I agree with that code doesn’t have a emotional import but it definitely has a performance import. The same idea can be implemented many ways in many languages and the performance can be dramatically different. Now you’d think all things being equal performance would be king but Python just sits there on the top of many hills happily unperformant in many regards.

@shanecelis @mjg59 the range of emotions that code can provoke may be somewhat more limited than or distinct from those invokable by arbitrary prose but like… come on. have you never felt mad looking at a piece of code? impressed? have you never appreciated how certain APIs provoke a flow state more easily than others? It doesn't *convey* an emotion in the same way that prose does, but neither does music, you don't write "BE HAPPY" out in quarter notes and then get the impact you want

@mjg59

I see what you're saying but also restructuring or making major changes to a novel *does* remind me of refactoring code. I think that's the part of coding that feels most like fiction writing to me - the editing.

@glyph Hmm I think I am maybe still not effectively communicating what I care about here. I think LLMs as code generators are going to be less effective than a skilled human, and I think that right now most people are burning energy in a pointless manner. But I don't see their reuse of code as as great a deal as I do their reuse of literature or music, because I don't think they're meaningfully mimicking the majority of the creative process involved in coding

@mjg59 what you're saying just sounds to me like a reversed "vocational awe" argument, where you've devalued coding as compared to "real art" for some reason. If that's not it, I don't get it.

@glyph @mjg59 Yes, that is true. My own experience often verges on disgust because I think code reveals more closely how people think procedurally, and that we think differently enough that it’s alien to look upon. Then again my own “good” code is also disgusting to me after six months away.

But yes, there are some good moments too that engender esteem, praise, and wonder like when I see ascii diagrams or Fabrice Bellard’s work.

@jwz @glyph Fair point, and also obviously commit messages play into this. If LLMs are tending to churn out people's comments I think my argument ends up massively weaker.

@mjg59 @glyph Anyway I've only been tangentially following this argument, but "code and prose are just different" has never held much water for me. They're not different and also you need both. Nor does the idea that LLMs are worse at one than the other, they're terrible at both.

It strikes me as the same old fallacy: "The most enthusiastic bitcoin and blockchain proponents are the ones who understand neither databases nor economics."

@glyph LLMs will happily regurgitate material in the style of a specific author or artist in a way that doesn't feel true of code, and that changes how I feel about a subset of the ethical issues

@jwz @glyph I'm solidly on team "LLMs are currently a net negative for software development even if you ignore the negative externalities", to be clear

@mjg59 If what you are claiming is true - that most code does not creatively express the underlying idea - then it is ineligible for copyright in the United States.

(Though I’m certainly not going to argue that judges understand the creative expression of ideas through code better than you.)

@tryst That was the state of affairs until 1983!

@mjg59

Pragmatic standpoint is completely valid, but don't forget why do we have writing systems: to convey information. That's the basic need. So taking the same pragmatic approach we don't need writers nor poets nor prose or anything of sorts: language exists to transfer data from human to human, and don't you dare to find any of that serialization into english/anything beautiful. Is that it?

@bsandro Not at all! But almost all users of software typically never see the underlying code, which feels like a significant distinction from literature

@mjg59

Okay, that was an extreme example but still.

But akin to woodworking or welding or anything like that coding is craftsmanship; ofcourse it is possible to make chairs en masse on a factory, but imagine you spent your career building them by hand. Why wouldn't you be proud of small bits and parts of every item you've made?

Just because some crafts are not as old - it doesn't devalue them.

@bsandro If I design a wonderful physical object and then program the CNC machine to make it, I'm proud of the design work rather than proud of putting the numbers in the CNC machine. To me, the actual act of coding feels much closer to that than it does to producing a hand crafted version of the same thing

@mjg59

Sure. But if it's just a matter of degree within the extant corpus, it is not a categorical argument.

Even the most boring code can be made significantly less elegant whilst remaining functionally identical.

Which means that although, maybe, sure it never crossed the threshold into 'beauty', there is an aesthetic dimension, which is overlapping with readability and maintainability.

So it is a dimension of code quality - not inappropriate to assess LLM generated code on it.

@MrBerard I was unclear in what the motivation for this assertion was, and I think that's left things confusing. I don't think LLMs produce code that is anywhere near equivalent to a skilled coder in terms of clarity or structure without significant handholding. It's more about whether I think the reuse of material is inherently ethically questionable in the way I think it likely is for literature or art or music.

@mjg59

Yeah, but you chose to make that point through aesthetics for some reason.

I don't know that people object to LLM coding in Open Source for reuse or IP, or originality angle? Or even aesthetics, actually

More that the capacity to generate massive SloC count is actually not a point in favour of maintainability, quality and safety?

How do you counter the argument that LLM contribs make repos less safe, more bloated, cause more review work unless you're willing to let a vuln thru?

@MrBerard I don't, and I also don't think those things matter to an individual just trying to make something work for themselves.

@mjg59

Also, the ethics of re-use in art or literature are the artefact of IP laws that are recent compared to these creative endeavours.

Fashion doesn't really do patents and IP, and this is why it is crazy creative, arguably to a fault in the case of 'runway' fashion design.

@MrBerard We've ended up in a situation where people feel they can never look at the implementation of a proprietary codebase to learn how it works because they'll end up tainted, even if they're only going to reproduce the concept behind the code rather than the aspects directly covered by copyright, and a lot of the LLM discussion feels like it's pushing us towards an even harder level of copyright maximalism

@mjg59 you have to look at the full picture. What you describe looks good because it looks like empowering: I know something about it, i early adopted a programming language whose promise is to empower everyone to build reliable software. But LLMs in their current political climate ain't that. They're not empowering because they create dependency to their use, and in doing so concentrate even more power in the hands of even fewer corpos. Letting you build stuff you don't understand is not power

@andi I'm not sure we necessarily disagree that much, then! I feel like there's a significant creative process getting me to the point where the code falls out, and that includes thinking about the overall structure, where components should be separated, where common logic should be merged, and so on. And to me the actual code that emerges is a representation of that work, rather than fundamentally *being* that work.

@Pi_rat

"The freedom to study how the program works, and change it so it does your computing as you wish" is literally one of the FSF's four freedoms

@Pi_rat And?

@mjg59
But we are. In fact my legal status is artist author of code. Because in France programming is recognised as an art when it is done with creativity. So you may be doing non creative code, just like some people write non creative text, or paint non creative paintings. A musician doing a piece for a commercial ad according to a specific script is very different from a musician performing his own creation on stage. The same applies to code. You can have creative and non creative code.

@mjg59 Are you using open-source hosted models or are we supposed to rent our tools from som company?

@mjg59

Erm...sure... Seems like you are now switching the fictional strawman against which you are arguing, but sure.

Then again, all creative endeavours require critical appreciation of prior work. No novelist doesn't read books, no miso doesn't listen to music.

So the point you are making, with which I agree, is in fact a point for coding being a creative endeavour (dunno if this implies an aesthetic dimension)

@mjg59

Another useless lazy coder that should be eating his own keyboard 🤢🤮🤢

Due to lazy people like you, is why exist abominations like Windows 11, Android or iOS. 😒

@mjg59 nope. because you're buying the crowbar from a dystopian megacorporation, and they're creating the crowbar out of bones from murdered puppies

@dgold @mjg59 Yea, but, like.. A functioning biosphere, human rights, a functioning democracy, respect for small peoples' creative rights, and code quality just aren't relevant to my specific use case

@mjg59 is it enabling it though? You have to use proprietary tools which you have no control over and cannot build yourself anyway. I might be wrong but I think gcc was one of the first tool RMS built.

A bit like being self sufficient food wise but you need to source seeds and fertiliser from “someone”, not to say big corp, and be happy because the seeds are free.

@mjg59 the model you own? you trained? with training data, all the people holding the copyright/left gave you the consent to use? you are not making arguments, you are giving excuses

@mjg59 bruh, masons spend their days gluing one brick on top of another and even they are aware that they can create beauty. Just because your projects have all the living energy of roadkill doesn't mean the rest of us are at that level.

@kyle TIL there's a debate about if it's elitist to tell people to learn programming if they want to modify programs.

@mjg59 🤡

@mjg59 as a writer and a coder, I have to say that there *is* a creative aspect to both and the same regions of my brain light up when I'm writing either. Code just have exacting syntax that must be obeyed.

@mjg59 I don't read other people's code save for documentation and snippets on StackExchange. That's not to say my code is unique, but saying "every line of code I write is a copy of someone else's" is more or less true about virtually every sentence ever committed to paper. Doesn't make your creativity any less valid. Doesn't make the problem you're solving or the app your building any less unique.

@mjg59 @Nfoonf Paying *people* to code for you: good. You provide income to a person who you can meet and respect and be colleagues with.

Paying OpenAI to code for you: bad. Coding is another rent seeking capitalist nightmare and enriches no one in your local economy.

@wouter @mjg59

I am not sure we disagree, I do agree on the fact that a tools that allow anyone to modify programs for their own needs is exactly what free software is about.

I disagree that what we have today is that though, feels more like a free drug for kids program right now.

To build domestic of them efficiently we would need to understand how they work… should not stop anyone of course.

@mjg59 for many it’s a Moral question.

There are two kinds of ‘free’ in OSS

Free as in beer: no downside you get something you didn’t have
Free as in piano: something so unwieldy you can have it if you can move it.

I’m not against free anything - but sometimes there’s a hidden cost.
We can be against hidden cost Morally *and* still enjoy free pianos - if you can move them.

@parodper Heh, not at all, but what there has been (although it has gotten a bit better over the last decade), is the belief among some in the community that code contributions to FOSS are the "real" contributions, and every other type of contribution (documentation, technical support, etc) is a second-class citizen.

@mjg59 What a bizarre take. One of those pipelines lets me feed my family, the other means layoffs for our entire sector (which is happening)

@platlas my preference would be for local models where the underlying runtime cost is more visible to users

@MrBerard words aren't just the embodiment of a creative story, they influence how we understand and feel about it. When I read someone else's code I'm not typically feeling that dual creative nature - I'm seeing the embodiment of the creativity that created a novel algorithm or exploited hardware behaviour in an interesting way. That's what I'm interested in, not the actual lines of code that tell the compiler how to implement that.

@glyph @mjg59 Yeah, this rubbed me the wrong way too.

As I see it, you can write code in a lot of different ways: from rules lawyer-proof legalese to shitpost, and all of these are valid. And that resulting code can be anywhere from painfully, boringly practical to something damn near poetry.

I've seen data wrangling that has flow and metre and fancy UIs written in code that nearly put me to sleep.

And this is the raw interpreted code, not the comments.

All of this is creative art, all of this is engineering (whether you like it or not) and all of this is ultimately just translating ideas into instructions for a very simple machine.

And yes, we all learned this craft by copying and pasting, but we learned from what we pasted and ended up learning how to steal the ideas and concepts and themes behind the "word"s.

My understanding of LLMs is that they're nowhere near the point where they understand why things mean what they mean, even if they can generate pretty plausible explanations for that, so they cannot generate output with "soul" whatever that means. Look at all the abortive attempts to generate videos for example.

I agree that LLMs have opened the field to people who would otherwise not be able to program and that this is a good thing. My manager wrote a coffee ordering tool that is both vibe coded bullshit and shockingly functional, and I believe he's learned along the way.

But would I trust him to work on our software product? Would I trust whatever tool he used to work on it? Fuck no. And thankfully, he's self-aware enough to not even try. As much as he's generated a useful tool, I know that the engineering behind it is nonexistent and I'd be shocked if he could explain how any of it worked at a low level.

As much as it is gatekeepery to doorslam the slop wranglers from open source projects, I believe that most of this antagonism comes from frustrations with people generating shit and trying to pass it off as gold without understanding or engaging with why it isn't.

And then we get to the moral and environmental issues outside of whether the tool can actually do the thing.

@juliancalaby @glyph I am absolutely not advocating for LLM use in software development in general, I am saying that the actual code is massively less creative than the majority of words or music or graphics consumed by the training and so I don't have an ethical objection *on that basis* (plenty of other ethical objections in most cases)

@Ced a proprietary solution that grants the user an ability to modify free software to match their needs is worse than a free one, but it's still something that enhances that user's freedom

@mjg59 @juliancalaby I appreciate the clarification on the scope of the disagreement. I still disagree, but you have gotten put disproportionately on blast in the replies. probably should have opened with this caveat :)

also despite that disagreement I think there’s an interesting aesthetic philosophy question in here and I wish we didn’t have to have this discussion while standing in the long shadow of the art-annihilating machine

@gardiner_bryant my choice of code is driven almost 100% by the desire to communicate my intention to another blob of code. My choice of words is significantly more complicated than that.

@corycarson I think the effects of all of this on the industry are terrible and also I think the arguments I feel legitimately apply to LLMs replacing the creativity of authors and composers and artists with a cheap imitation are much less strong when applied to the regurgitation of code

@jwz @mjg59 @glyph I hang out with three guys who use AI.

Guy 1 works at a rocket company and says he'd never use AI to design the part he works on, but uses it for little bits of code. Guy 2 works for a social media company and won't use AI for code, but uses it to write email reports to VPs. Guy 3 works at Microsoft and says AI is great as long as you don't use copilot.

They all think AI is good at stuff they don't understand and sucks at things they do.

@mikej @mjg59 @glyph
The tech industry loved Langford's Basilisk so much they made it real.

I also wonder if bulk brain damage and disinhibition from 7+ COVID infections is an inciting factor.

The "find out" phase is going to make this decade look worse than leaded gasoline.

@mjg59 It misses the point so completely (and doesn't address any of the actual counterarguments I've seen made) that it is functionally indistinguishable from a piss take.

@mjg59 i see so many people on here going on and on about how llms write bad / lazy / sloppy code, and im like, if you think that's bad hold my beer i can do _far_ worse

but yeah the gatekeeping vibes are real rn

@mjg59

I'm a full-time professional novelist. Have been for 25 years. Before that I was a software dev. From the inside, the cognitive experiences of writing prose fiction and writing software *feel identical*. The creativity exists outside the words, and most of the phrases and grammar I use are unoriginal.

Ball's back in your court.

@jwz @mikej @mjg59 @glyph Tetraethyl lead in petrol is next on the Trump administration's to-do list, just as soon as RFK Jr. manages to ban all the COVID vaccines.

@cstross @mjg59 one icebreaker interview question I used with coders for a few years now is "do you think programming is a creative or an engineering thing? No wrong answers here!"

I think this might be a relevant question here :)

@cstross Ok that's interesting and does make me reappraise my position. I don't write for a living, but I spend a great deal more time thinking about choice of words than I do about choice of idiom in whatever language I'm coding in. The number of ways I can reasonably convey "modify this register" to a C compiler is extremely small, the number of ways I could describe it to a human is massive.

@mikej @mjg59 @glyph Running with the leaded gasoline analogy:

LLMs have managed to turn Github into a Superfund site.

Future decades are going to have to spend trillions to even partially remediate the damage done by allowing slop to leech into the soil and aquifer.

@mjg59 @cstross The number of ways to end a sentence with a synonym of "he said" is also small. That's not what writing is.

@jollyorc @cstross @mjg59 I would have, of course been obliged to answer 'yes'.

For me good code can be poetry in its expressiveness. Yes there's only so many ways to tell a compiler to modify a register but there are also only so many words for a sheep. Its how they are put together that matters

@jollyorc @cstross A distinction I'm drawing that's maybe non obvious is that I'm separating the "Figuring out what the code has to embody" from "Producing the actual code" - the former step feels creative and is the part of the process that satisfies me in that respect, the actual "typing into the box" satisfies me in the sense that I've turned the first step into something real, not in a sense that I've engaged in further creativity

@jwz @mikej @mjg59 @glyph

Well, two of the most common persistent cognitive effects of COVID - memory loss and attention deficit - are ripe for having a fake cybernetic solution swoop in like LLMs and "fill the gaps".

Also, my guess is that low grade CFS and sleep disruption is *widespread*, and most people have less energy overall.

Automation sounds good when you've got no energy.

@cstross Lead before CFCs?

@jwz @mikej @mjg59 @glyph

@mhd @jwz @mikej @mjg59 @glyph If you posit that the goal of the oligarchy is to kill 7/8ths of humanity so they can own all the remaining natural resources, then reintroducing CFCs would be a logical move. Followed by smallpox.

@jollyorc @cstross @mjg59 another way I think about this though is what am I trying to do. My shopping lists are not poetry, and some of the code I write to solve a problem is no more epic prose than many more functional bits of writing, nor is my photo of a business card for the number art. IMHO intent and purpose matter

@mjg59 @glyph this will not help people, allowing vibe coding will soon become an unmaintainable mess cause no one will understand anything anymore (the model is doing the "thinking.") And once the ceo's got you acting like a gambler at a slot machine, throwing token after token into models (one more prompt to repair the bugs the last prompt created, etc.) they suck you in with a sunk cost fallacy and you self justify continued use. And then the actual goal, ceo profit at the cost of humanity's autonomy.

@ailurocrat @glyph Allowing vibe coding in places where we currently have humans in the loop, yes. But that's not the only possible outcome!

@cstross yes! When I was coding my brain had to imagine what the code would do (or try to do) even before typing out the line. I usually worked with Perl and regular expressions which heavily leaned on the creative and previsualization side of coding. @mjg59

@etchedpixels @jollyorc @cstross I absolutely don't want to deny that code can't be art - IOCCC entries are absolutely are, for example. But I feel like the overwhelming majority of code doesn't fall into that category, and so I don't feel like having a machine replace a human in the process of turning a well formed idea into code is an assault on human creativity in the same way that having someone type a plot into an LLM and hit "go" and publish it on Amazon is.

@cstross @mhd @jwz @mikej @mjg59 @glyph JFC Charlie that's dark AF, but not off target at all

Unfortunately.

I hate this timeline

@cstross @mhd @jwz @mikej @mjg59 @glyph I wonder if we could get a “gargle tetraethyl lead for brain boost!” fad going with the tech billionaires. I feel like it’s the kind of thing they’d actually try.

@mjg59 @cstross if code weren't substantially about communicating information to other humans as well as the compiler, we wouldn't have comments or version control or commit messages or even bother to share source at all.

How you code something is meaningful communication to other humans (including your future self), and the way you do so matters to their understanding of your intentions and values. Code has both text and subtext.

@mjg59 @jollyorc @cstross the writing is the thinking and figuring out. I’ve never had an idea, whether it’s poetry or code, that’s finished before i write it. the writing is where you realize all the ways that you want to rethink what you’re trying to do, or where what you imagined doesn’t actually do what you want … it’s in those details of the realization that the concept and goals and values are clarified and made real.

not all implementations are equal, even if the specific outcome is the same …

@jwz @mjg59 @cstross Exactly.
Why do AI fans always argue like they are sun-downing shortly?

@wordshaper @mhd @jwz @mikej @mjg59 @glyph I hear your tetraethyl lead mouthwash and raise you dimethyl mercury.

@cstross @wordshaper @mhd @jwz @mikej @mjg59 okay I feel like I have to ask just to be sure: is the bringing back leaded gasoline thing a joke? I know better than to be sure it isn’t

@soc @jwz @cstross My job right now is dealing with the consequences of massive LLM use. I am absolutely *not* a fan.

@megmac @mjg59 @cstross +1 to Meg's comment, with an addition: I have found LLM code substantially harder to *read* than human-written code, precisely because the latter has a coherent idea being expressed. I'm not sure how to quantify it, but it's definitely there.

@mjg59 @distrowatch
*snif* having an emotional moment here for someone saying something on the internet that was actually true for once.

@mjg59 @cstross ... the wider goal is not "increment this variable", but something (hopefully) much more profound.

One of my largest concerns with LLMs is that they simply regurgitate a pattern they've been trained on, and which appears to match the situation / statistical prediction.

There's zero "thought" about how the output fits with the rest of the codebase / functionality, and no consideration for side effects / security implications / etc...

I'll admit I've not touched "agentic" stuff (perhaps I'm missing out, but also filesystem access? execute permission? hell no) ... from my goodwill attempts with "chat" style LLMs there is a clear willingness to lead you down an overly complex and objectively worse solution.

For the basic-basic "how do I get started with ${thing}" (e.g: React in general, not specific things), it can unblock you - but you need to be constantly on the lookout for it feeding you bad ideas, and keep your skeptical hat on at all times.

This paired with the evident cognitive impairment and psychosis, it seems like an incredible way to de-skill.

Looking at the big projects, things like Moltbook (trivial and fundamental security flaws paired with a "zero code written" claim) and OpenClaw (terrifying level of access with a very real prompt injection threat) ... I think the biggest issues here are the full-faith approach so many have, and the lack of separation for trusted vs untrusted input, something which I believe is currently entirely unsolved. "Sanitize your inputs!" is an ancient mantra, and doesn't exist here(?!)

It's early days, maybe it'll get better... but people are diving into this like it's a stable and reliable technology - and, in my opinion, that's terrifying.

edit: to expand this - I work in a team with engineers doing a significant amount of not-software stuff, and their willingness to use LLM output (even for safety related things) is also a large concern for me. This isn't a discussion constrained to software or even electronics, it's much wider.

@attie @cstross My experience is extremely mixed - giving an LLM a prompt that's roughly equivalent in detail to a problem statement I'd hand a junior developer results in code that looks pretty much like I'd expect a junior developer to write. There's nothing novel in its output, nothing that sparks any feeling in me - but nor would I expect there to be in something a junior developer gave me.

But the way people are deploying and using this stuff? It's terrifying.

@mjg59 @etchedpixels @jollyorc @cstross Sure, there's a lot of mediocre writing out in the world too. Sturgeon's Law applies everywhere.

I'm pretty strongly in the camp that having an LLM spit out mediocre slop (and I feel like that's being generous in most cases) *is* an assault on human creativity whether it's prose, pictures, code, or whatever.

It's also an assault on quality, comprehensibility, and maintainability, which are all pretty important features of well-written software.

@swetland @etchedpixels @jollyorc @cstross well yeah, but we've all engaged in terrible and unmaintainable hacks to make something work locally with no intention of sharing it, and someone using an LLM for that specific case doesn't feel like an issue for me in that specific regard (all the other externalities are still giant fucking issues, obviously)

@mjg59 I code because it makes me FEEL GOOD. I've been coding since I was 12 and now I'm 44. If coding was just about getting the thing done I would just stop coding. And once AI gets good enough that's what I'll do—Walk into the sunset and find something else to do.

@ezivkovic it feels good to me because I'm bringing my idea into reality, and there's huge satisfaction in that

@mjg59 art reduced to a subscription

@johnzajac Debugging absolutely requires the short term memory COVID infection shreds. Current ability to debug is not great.

Most people currently employed as programmers are able to remember being able to do this stuff, and vaguely how you do this stuff, but they can't actually do it anymore and are desperate to keep people from finding out that they can't do their jobs.

It makes LLMs very popular; it doesn't get the job done but it does let you look busy.

@jwz @mikej @mjg59 @glyph

@graydon @johnzajac @jwz @mikej @mjg59 @glyph Long covid took away my ability to interpret symbols for months.

I went from a paperback-a-day habit plus intense cognitive work to picture books because I couldn't hold a word and its meaning in my head simultaneously.

I lost English, math, music, programming, graphs - everything that involved interpreting symbolic information. Spell checking was like crawling over gravel.

These were all things that I *knew* I used to be able to do, but my brain couldn't access the actual skill anymore.

Doing something by writing a prompt would have been just as difficult as doing the job. And evaluating whether the prompt accomplished the task or not? Impossible.

(I'm better now, but bad symptom flares still trigger cognitive impairment and my ceiling is nowhere near where it used to be. On a bad day I communicate the same way an LLM does - by having chunks of pre-stored communication that fall out in response to the right trigger. I'm crashy today and had to deploy the chunk that means "I'm not comprehending what's going on and can't answer questions right now".)

@Robotistry @graydon @johnzajac @jwz @mikej @mjg59 That sounds intensely miserable, I'm so sorry to hear it 😢

@cstross @mhd @jwz @mikej @mjg59 @glyph por qué no los dos? Two great tastes that taste great together!

@jwz I guess code and prose are different enough at the level @mjg59 is talking about. Code is much, much stricter than prose, and the ways of expressing beauty in/with code are at a different level than with prose. You can have beautiful short sentences in writing, like haiku etc. and the same thing in code is hard (code golf? hm).

But yeah, I do believe both code and writing can express the same kind of beauty.
@glyph

@mjg59 so, you Don’t like the profession.

@jguillaumes No, I love coming up with creative solutions to problems, and I find the process of churning out the implementation of that solution to be satisfying. But for me it's the concepts, the algorithms, the preconceptions about the structure of what I'm building that are the creative part of it, not what's happening as I emit code that will then be consumed by the compiler.

@mjg59 @glyph you're missing the point. Giving those grifter sociopaths (the ceo's) money is bad enough, (and they fund pure evil, don't even get me started on that one) but it feels like it's a variant on the Abilene paradox. (https://en.wikipedia.org/wiki/Abilene_paradox) Plus, its fucking with software freedom with the unclear licensing thing.

@ailurocrat @glyph You can use a local model right now without funding anyone. And if someone isn't distributing what they produce then I have a hard time caring too much about the copyright status of the material the tools produce.

@mjg59 @jollyorc @cstross Long before AI there were the same discussions about people who used hypercard or hacked stuff up in dbase or did terrible things in excel. For most people the question isn't I think "can I make an LLM write a program" it's "did the device solve my problem". I kind of get it because that's my attitude to carpentry. I am not a craftsman my test for my model railway carpentry is "will it stay flat and in one piece" and I'll happily swap framed insulation for carpentry

@adriano @mjg59 @glyph That depends very much on the prose! Try writing an RFC. Or a zoning regulation.

It's like half the people in this thread think the only kind of programming is bit-banging an Apple ][ Inkjet driver, and the only kind of writing is Game of Thrones.

@cstross For me, they use the same machinery in incompatible ways: after a couple weeks’ intense coding, I could barely write a coherent sentence. (Perhaps) despite that, I fully agree that the processes feel identical; I just can’t do them at a high level too close together.

@mjg59 @etchedpixels @jollyorc @cstross There are a number of reasons that I no longer work for big tech and the "ai" madness infecting the entire industry right now is a big one.

It's amazing (and depressing) to me how it appears to be accelerating software quality just falling through the floor across the board.

At this point, I'm hoping there will be enough folks who remember how to write software after the industry finishes utterly destroying itself and maybe we can start fresh then.

@mjg59 Sorry for coming on a bit strong, thanks for the clarification.

I would agree with you that there's a strong notion of "conceptual value", if you will. And I think that's where the creativity lies in programming. It's a different kind of creativity, sure. But it matters a lot, and it's not something that can be replaced easily.

If programming is a simple, purely mechanical process to you, I would hazard a guess that you're solving boring problems in boring ways.

@mikej @jwz @mjg59 @glyph

I try not to intentionally go near AI these days…but in my previous job which I had last year, a huge amount of my time was spent crafting complex defensive email responses on behalf of my then boss to senior management and clients…if my boss requested I draft one of these way past my working hours, I am only a bit ashamed to admit I got AI to do most of it. But I’m not alone, right?

@jwz @adriano @glyph I think it's more what the perception of the common use cases looks like. When people talk about LLMs replacing writers they seem to be focused on writing we'd recognise as strongly creative (even if what comes out of the LLM isn't...), but when it comes to code it's largely commercial boilerplate. The emotional reaction we have to seeing a machine do each of these seems different, but most of the conversation seems to draw equivalence.

@luatic I think I'm largely solving interesting problems in boring ways, tbh.

@jwz @adriano @mjg59 @glyph I spent the better part of 30 years writing kernel and driver code, and in my experience there's usually room for quite a bit of creativity and expressiveness even in "low level" driver code. In most situations there's "bigger picture" stuff to consider, beyond line-to-line writing-the-semicolons coding.

And clarity matters for anything that's not a one-shot throwaway script or prototype (even ignoring how often management decides you should ship the prototype).

@mjg59 @attie @cstross I think there is something here that is revealed.

A problem with vibe coding is that you have to specify everything at the start. It assumes you have a clear and correct idea of what your end product will be. But a lot of coding evolves and needs to be clarified as you go. This is the whole idea around agile, that if you have missed a requirement, that it'll present itself as a problem when you get to it. Vibe coding skips that whole piece, so if there is a problem that you have got that is fully specified, then a LLM will produce something that (probably/maybe) will fit like a junior programmer. *But* if you've missed something, then you will have a result that doesn't do what you want, and you probably won't know why. You'll have to guess and respecify until you get it.

I think this is why vibe-coders think they are doing great, because they are remembering when they fully specified something and it worked, and it may be why others have really bad experiences, because there was a hidden problem that turned the whole thing to shit and was really hard to fix.

@mjg59 @jwz @adriano @glyph There are a lot of people out there who seem quite convinced that LLMs will completely eliminate the need for programmers or programming "as we know it".

Admittedly, I've seen this claimed about a variety of technologies over the past few decades, so it is hard to take seriously even before one sees the quality of the resulting code.

@glyph @cstross @wordshaper @mhd @jwz @mikej @mjg59
Yes.

@mjg59 I don't get that impression at all. Much of the LLM hype for programming appears to me to be "programmers are all obsolete!" form, like the people who are vibing up entire "replacements" for SaaS businesses.

@mjg59 you started with opensource and ended with commercial boilerplate, and I have concerns with both.

[with my OpenBSD developer hat] Arguably, (opensource) projects themselves are works (of art) that their maintainers care a lot about. Yes, anyone can contribute, provided that they understand what they are adding or changing (preferably every line), they are the author of their submission (so that they have the copyright to give), and the submission is accepted by the project. LLMs check none of these boxes. At least where the maintainers care about having a maintainable project.

[Switching to my product security hat]
When it comes to commercial code, think about what happens when all the effort security/quality folks have been putting into removing technical debt and any progress made towards maintainability and correctness is destroyed when developers arbitrarily decides to rewrite a large piece of code using an LLM. Basically it is the security and quality folks who suffer from the "work" that developers "save". It is mainly transfer of workload from developers to testers who barely had resources to begin with. Also, no, just adding more (security) testing resources or offload that testing work to LLMs does not help. It is orders of magnitude harder to review and test unengineered LLM generated code than to test and review a properly designed code base.

One only needs to look at the Claude Code source (and various analysis here) to see how bloated and unmaintaintainable it is.

@jwz @adriano @glyph

@canacar @jwz @adriano @glyph I promise that you do not need to try to convince me that the impact of people unable to understand code opening pull requests is terrible!

@mjg59 I am trying to convince you that LLMs do not improve the amount of pull requests coming from prople who understand the code. It significantly increases requests coming from clueless people, and teams are already feeling the burden. Even when used by people who understand the code, LLMs do not provide provenance/authorship information, so it is still a showstopper. @jwz @adriano @glyph

@canacar @jwz @adriano @glyph The one case in which I'm suggesting there is a potential benefit is in people who don't know how to code being able to modify code to meet their local needs. That code should then stay local.

@jwz could always just pave over them and use the freed up IP address space to host the next geocities

@cstross @wordshaper @mhd @jwz @mikej @mjg59 @glyph

I hear that the court Wizards have finally figured out immortality using quicksilver, for real this time…

@mjg59 good for you; problem for me is that Jensen & co are really good at convincing business leaders, including my boss and his boss, that this is the future and that all of our development should be done in "agentic loops". And the thing of beauty I dedicated my life to is still there, but soon I won't be able to do it anymore. They replaced the live band with a spotify subscription.

@ezivkovic sadly there's a limit to what I can really publicly say without it turning into a problem, and this is probably where that limit is

@mjg59 an LLM cannot create this beauty.
https://github.com/Gunstick/Colorful-Boxes/blob/main/SOURCE/COLBOX12.S
When I was done writing this, I had an overwelming feeling of amazing satisfaction to have created awesomness.
If you had never that feeling, then you have never really coded.
#demoscene

@gunstick what I have been learning is that my experience is not everyone's, but also fuck the idea that there's a "real" anywhere here. People who sing are singers. People who write are writers. People who code are coders. There's no uniform experience that qualifies someone for the title.