Clojurians Log v2

Maybe I'm not following, but I guess "senseless" is the important word there, since not all rewrites are senseless. When you choose a lang/ecosystem you choose a set of trade offs that remain fixed forever, while your project context doesn't (perf needs, devs availability, etc). And these re-writes use to be very expensive and tedious and now that seams to be changing?

Not more senseless than the asinine fad of rewriting everything and its mother in Rust. I'd consider them more senseless because investing a lot of effort in a glorified rewrite is sillier than investing low effort (Looking at you rs core utils)

The rewrite of the ts compiler from js to go (probs not done by a bot) was huge for us, unless of course you liked fencing.

I think it's both. Some rewrites/port are genuine, and intended to be well maintained and done with care, even if heavily assisted by AI. Others are someone trying and experimenting with something that gives a pretty satisfying result which you couldn't have dreamt of achieving yourself in the past and with surprisingly good results because it's a great use case for AI.

The annoying bit is the latter group making big release announcements and some of them are suffering from AI psychosis where the AI has been greasing them from the start, like wow we've achieved 10x performance speedup and look at all these benchmarks I'm running, your port is exceptional and innovative, etc.

@xnooga If you've been handcrafting it for 5 years, then it's not slop by definition. If you use AI to advance the project in ways where you understand what you are doing, then power to you. I'm triggered by 2 week old repos with 1000+ commits that reach #C06MAR553 saying "look at what I did!". Well, no, you didn't. And for some reason, X-in-Y ports seem more lucrative to those folks than other topics.

As the maintainer of one of those lately-AI-heavy ports I don't know how to feel about opinions like this.

Most of my impl was handcrafted over the span of 5 years in my spare free time because I wanted it to exist. Simple as that. It turned out to have nice properties - it's small and it boots fast. So much so it's actually useful and used in prod. We've switched to fully AI driven workflow to increase Clojure compat, squeeze out more runtime perf and introduce proper native binary AOT.

I'm kind of curious if this qualifies as slop in your view @alexyakushev.

Not OP, but for me, the issue is I don't know if you know what you are doing or not. Could you have implemented it yourself without AI? Are you able to assess it's doing things properly and in an ideal way, are you committed to a high quality bar, a long maintenance, consistent long term evolution with limited breaking changes? Did you thoroughly test it yourself, not just trusting the AI unit tests passing blindly, etc. And I think it's especially hard now, because for every high quality release there are going to be many other similarly looking poor quality ones and I can't tell them apart.

I see, thanks for answering. I understand, yet I don't see why would anyone be interested in judging an open-source project on these unless they are planning to put it into serious use. And even then, IMO use of generated code is kind of orthogonal to the quality and usefulness of the codebase.

For something like a language impl I think it's impossible to make it work and reach decent correctness and perf without significant care and domain knowledge.

I am thinking of using them for serious use 😝. If it's just a "look what I did, please don't use it seriously I don't know what I'm doing" type of thing, that's totally fine, might not be as impressive anymore since it's not as incredible a feat with AI, but if it's got interesting ideas I might still look at it. It's more the disclosure I guess, if that's the case, don't present it to the world as a serious thing. In the past the difficulty of the task itself meant that very few non-serious open source projects were released in a usable and relatively feature full state. So when you saw something released that appeared polished and well featured and working, it was enough to know the person was serious about it. Nowadays you just don't know. And as a user, I'm not always qualified to say if the project appears serious, if the implementation is tasteful and non-sloppy, because I don't always know enough, like say for a language I don't know compiler design that well, so I'd be a poor judge. Or even when I know, with the flood of options now, I don't even have the time or energy to assess each one for the same. And even if the code and everything looks good, now you can't tell if the person is committed or it was just a weekend experiment.

also optimism bias, things seem easy before you attempt them ("it's just ...")

Also people tend to find making a new language fun and cool, but now the upfront total cost to dabble in it seems to be lower. or they want to fix a tradeoff their favorite language has by just hosting it somewhere else. Which lends itself to people believing that they could get a perfect language if they just mix the good stuff from A and B, without necessarily understanding the original tradeoffs and underlying limitations.

Will the smart high school kids choose this field if AI becomes the standard way of doing things? Are we facing an existential risk?

it's ok if smart high school kids choose other fields though

I think software will remain important, even if how it is made changes

That seems to be more pertinent to #C0353589RFC.

I thought I couldn't post there, but I may have gotten it confused with the community announcements channel 😵‍💫

Since #C06MAR553 (and #C015AL9QYH1) are where individual project releases are posted, this seems like a poor ask to me. Suppose I have a well-established project, and I'm making monthly announcements of releases, and for one of those releases, it includes a PR that was AI-generated, but everything else in the release was human-generated like all the previous releases. Are you really asking me to label part of the release announcement with "something something AI something" so that you can judge the project, or judge me for accepting an AI-generated PR? That really doesn't feel in keeping with https://www.clojure.org/community/etiquette -- "They are not the place for advocacy about what 'ought' to be made. If you think something ought to be made, then make it. Otherwise, respect others peoples' right to choose what they do with their time. Occasionally, there may be disagreements about how something has been, or will be, made. These disagreements should take the form of technical arguments."

You're certainly free to ignore a project if you don't like how it's made but you're not making a technical argument here.

In addition, it feels like you're trying to create a burden on all project creators/maintainers to label every announcement/release, to suit the non-technical desires of a handful of vocal critics of "how something has been ... made" which feels like a really one-sided proposal.

And finally, you'd be creating a burden on the Admin Team here to police this -- because what's going to happen when someone posts a new release and some random person figures out "Oh, they used AI!"...? That random person is probably going to complain in a thread on the announcement, creating a hostile environment for the maintainer, and likely dragging the Admins into it -- because that is exactly the sort of behavior that led to the creation of this channel, so we wouldn't have "drive-by criticisms of how something has been ... made". Again, see the Community Etiquette page.

Would you be burdened to police it any more than you police spam? The idea is similar to a spam filter. While not actually spam, AI slop has the same attribute of being a low quality output: a waste of time and energy. However, it unfortunately has a much more similar appearance to high quality output than traditional spam does, so we have a new modern problem to solve.

Spam is, by and large, trivial to detect. But how do I determine the quality of the output and where the bar lies?

@soltanzadehramin It would be an additional admin burden and we're already volunteers devoting time to dealing with spam -- and violations of the Code of Conduct and Community Etiquette. In addition, "quality" is very subjective. I've reviewed some vibe-coded code and it's been really good and some has been awful, so it's not even black and white.

I don't think it necessarily needs to be a strictly enforced rule to be effective. As long as it is declared as an expectation the community itself can ask the announcers to provide that information if they omit it. It could become a self-enforcing thing where announcers get incentivized to be upfront about AI use to spark the interest of readers. And who knows, maybe the honesty is a larger part of the problem than the AI use itself.

@christian767 For the sake of distilling the point - is it really a vague usage of LLMs that's the problem, or is it basically stuff that shouldn't be looked at with any scrupulousness? Because the former doesn't always result in the latter, and the latter doesn't always require the former. Or maybe it's something else entirely?

I was thinking someone needs to come up with the semver of AI disclosure. So we can all have a standard with a badge or something. Then it can become easy to disclose the "level of LLM" like no AI at all, no AI written code, fully reviewed AI code, skimmed at AI code, black box tested AI code, fully vibe coded. That said, I don't know if that's going to help much. I feel more importantly is maybe to disclose the level of commitment to quality, maintainability, non-breaking, etc.

Outside of Clojure, I think a lot of people are at level 6 but would never admit it and claim level 3-5 instead.

As long as a mindset is developer did it = good, ai did or helped = bad, no system will solve whatever trust issues people might have. I'm pretty discouraged about this whole thread so far. I have no issue with people deciding to ignore code that was created with help from AI. I also have zero issues disclosing it (I have done so from day one). But the way I (and perhaps others as well) feel I am described here as a person that has moved to the dark side is not something I expected in this community that has always been super helpful so far. I am seriously considering not announcing anything anymore. Not because people will ignore it. That is fine. But because I get the feeling (this is my view given this thread) that I am some incompetent or inferior person. That isn't why I write code. I write it because I enjoy the work , coming up with something I like or need, and because it is fun to see it used in reality, by myself and perhaps others. AI does not define me, it is one of the many tools there are and I use. I've created one library where I build the first component myself and then used Claude to essentially copy that component to different variants. It saves time that I do not have and makes the library more useful for me. I'm now working on another idea (more complex for me) and i have used Claude in the brainstorming and architectural phase, by letting it ask me questions to sharpen my thoughts. I write the code, and Claude is used for reviews and for tests. It makes life easier for me. Does that make me a bad person? I don't know. But in this phase of my professional life this is all I have time for after work. If any of that is something others do not wish to be bothered by then the best thing is to stop announcing it.

> wasn't that your argument against disclosure? @didibus I'm not against disclosure, just questioning usefulness (pros and cons) of this labeling idea on announcements, because what the LLMs labels means today for people, since there are cons to labeling.

Honestly I think we're digging a hole here and positions are getting a little bit exadurated/amplified by the fact that this discussion is happening in async text rather than in person. Most of us are naturally/voluntarily disclosing when AI has been used (I'm [g]ai and I'm proud -- well, unashamed maybe), because honesty/attribution... And will continue to do so independently of this debate. Those who have a strong bias against can maybe evaluate those declarations in the context of any previous interactions with the declarant and/or their work and filter accordingly, and decide for themselves whether or not to look at announced work that doesn't include a declaration. Anyway, I'm stepping out of this one now I think. Be nice all y'all - hey it's Friday!

@alexander.vanelsas I use AI because I'm tired too, I have young kids, AI is amazing for that. That said, I think the position to just put a hard line on AI usage can make sense. The users are tired too. They're tired of looking at announcements and projects that aren't worth their time. As another poster related it to spam, they found recent announcements are low effort work that can't be relied on, creating noise that hides the ones that are worth their time, same as spam would. So some of them have decided to just not bother with projects that use AI. It's a wide net filter, but it's simple. Because I use AI, I'm very interested in this problem, and I also felt that same pain as a user. How do you make a better net though? Many just want to be able to distinguish projects that use AI but the author remained in the loop and has already done the hard work to make sure it's high quality, reliable, or innovative. This is where AI as a tool analogy breaks down for me. It can be a tool, but it can also just spit out autonomously an entire open source library without so much as even an idea. I can just prompt: "Make a super cool Clojure library" and boom something comes out and I announce it.

@didibus as I said before I have zero issues with people deciding to ignore AI projects all together. I do have issues with the implicit suggestion that all people that use AI in some shape of form are somehow inferior in whatever way. Personally I build things I have an interest in and I want to learn more about.if other people like it, so much the better, but that is not the main motivation. If I am implicitly labeled because i use AI as a tool, then I feel it may be better that I just quit posting stuff I am happy about myself. Makes life easier for everyone else, and it gives me less stress about how people might view me or my work.

@alexander.vanelsas Absolutely, I might have missed it if anyone was implying that, and I do condemn it. It's good to be self-aware though that what was an impressive demonstration of technical prowess before, is less impressive if you've had AI assist you in it. As well as that you are using a highly controversial tool which has the potential to impact other people's way of life negatively. I trust this community can navigate that without personal attacks.

My argument is that unsupervised LLM output is not the same as "I made this". Your response ascribes me several motivations I have not expressed @seancorfield, which I find quite unnecessary. In any case, message received: there's no interest in disclosure rules.

The problem with the OP is its vagueness and a consequent inactionableness. Why are LLMs a problem in the first place? Hence my question above. Is "unsupervised LLM output" different from "I wrote it myself in a delirium, I can't even understand that code" or "I rewrite the project from scratch every other day in the pursuit of perfection"? Does it matter that an LLM has generated 100% of the project if 100% of it was scrupulously reviewed? And so on, question after question, if we delve into it. Questions without which we might end up close to what the "Open Slopware" project is doing, with every itty-bitty aspect of LLM usage tracked for the sake of... something.

We made the decision not to use libraries made by LLMs, so it would be nice to have this kind of "disclosure" to avoid wasting time and effort before realizing that the code is not maintainable by humans.

I'd also like to know how a software has been made and if a human has seen the code. I don't think an enforcement is practically feasible so far. So this could be a community rule without enforcement or admin.

@asier.galdos You're missing my point. What exactly does "made by LLMs" mean, really? If the only thing you care about is whether or not the code is maintainable by humans, then LLMs being involved to some degree does not immediately necessitate any maintenance issues. I've seen plenty, plenty of fully human-written code that I would call completely unmaintainable - where a single fix would take an enormous amount of time and would result in two new issues.

We care about many things, not only that, it was just an example I used that has happened to us recently.

By "care" I meant the context of the thread, not the context of your whole company. :)

I only know that we need to somehow filter all the AI cr*p that is populating this slack.

https://data-star.dev/star_federation#coded-by-hand makes me happy.

Somehow I think it's fair for the clojure community to value hammock intelligence without losing its ham.

I guess this is a good moment to fall back to first principles: What would Rich say? https://gist.github.com/richhickey/ea94e3741ff0a4e3af55b9fe6287887f

Nothing in that missive is relevant to the thread though.

What is relevant are the concerns raised about AI generated code, and there are many more than what Rich expressed that are more technical in nature, e.g. maintenance, security, etc. This is not just a clojure issue but a wider one, so we'll see how that evolves. But without falling into the for or against debate, the simplest and most sensible thing is to encourage authors to disclose how AI was used or not. I think this is a fair ask as the concerns are not negligible.

What is relevant are the concerns raised about AI generated code

The answer to your question is the same as what leads git and VCS in general to store the author of a commit, which I hope you value.

I don't see any analogy here. Not in the context of the vague "AI was used to some unknown capacity". Not even in the context of "AI has generated all 100% of this project at the behest of %username%".

The whole computing community has led the way in ensuring attribution is given (unless waived) and all of a sudden we forget about that for machines?

So is this thread about maintainability or attribution? If a commit is made with p-himik as its author, would it not stand that it should be attributed to me, even though I might've used some LLM to generate its contents, or I might've hired someone else to do it for me?

Maybe you're right in asking for more precision of what it means to disclose AI is used, but do not let that obfuscate the larger issue at hand which is authorship.

Unless I missed something, you are the first in this thread who brought up authorship. :) I personally do not see it as a larger issue by any means.

Maybe our way of attributing authorship is not 100% perfect, but we can't just use that as an excuse to not care about it.

I'll just go ahead and say that the problem of authorship in general is completely off-topic for this thread. Unless the OP comes back and explicitly says otherwise. Feel free to start a new thread though.

> I personally do not see it as a larger issue by any means Ok so you do not care about who authored some software you use? Imagine then AI is increasingly used without attribution and somehow some AI gets perverted and insert malignent code into thousands of libraries out there. Tell me again you do not care.

exactly the same might happen to human contributors.

> Ok so you do not care about who authored some software you use? Why do you jump from comparisons to an absolute statement?

sure humans are as fallible but does that mean we let go of that issue with AI? One thing AI does well is to magnify our ways of doing things, especially the wrong ways, notably in architecting and securing software.

> exactly the same might happen to human contributors. Has been happening for the whole programming history, in fact. :)

The point is that we quickly can see if Hibernate and Swing is used by inspecting the repo, so this problem does not exist for those situations. Imagine if it were not possible to see whether Hibernate and Swing were used (not that I know anything about these two frameworks, but continuing with your example), and you also have an order of magnitude more code to read on top of that. It is a problem that you'd need to find a solution for. Insofar as AI is being used to outsource thinking, it is a problem. If it's in a small capacity, then it is a small problem. Because outsourced thinking is what trades off quality for speed, and it is not immediately obvious that such a trade-off has taken place. You could probably distill it down to "We would like it to be immediately obvious how important the quality of output is to the authors." Do you think the expectation of AI disclosure would be ineffective for this? Or do you think there is an even better solution?

> does that mean we let go of that issue with AI no, why do you think that?

The point is that we quickly can see if Hibernate and Swing is used by inspecting the repo

@delaguardo @fmjrey Please create a new thread for attribution.

To put it simply, many of us think, due to many reasons, that it would be nice to have some kind of disclosure message like @didibus has suggested above: "level of LLM" like no AI at all, no AI written code, fully reviewed AI code, skimmed at AI code, black box tested AI code, fully vibe coded.” Why are you reluctant to have this? I don’t understand.

@asier.galdos Nothing in your message is actionable. At least not something the admin team can do without spending the time we don't have. Any action is not better than no action in this case.

I don't think it needs to be a rule. I am not even sure admins need to do anything here. It's possible the community itself can drive this issue on its own by inquiring authors about it. But it is also possible that that is not enough, so discussing possible solutions is good. I'm sure the OP is more about highlighting the problem and inviting to a discussion about brainstorming a solution rather than advocating strongly for a particular solution.

I don't think a new thread is needed, I'll just end with this: I do believe attribution is the issue being discussed here, and it goes beyond this community. Because we have no reliable way today to give proper attribution to AI, best is to rely on author disclosure.

> the community itself can drive this issue on its own by inquiring authors about it Yes, as long as it adheres to the CoC.

Authors that code by hand should have more respect, more funding and recognition by default. This is a broad problem happening in many fields. The amount of BS is unbearable. Genuine work should be recognized more, because AI is not just another tool: it’s mainly a glorified copy-paste tool.

Isn't there even more nuances here, such as “produced by an LLM, steered by a human developer, 100% reviewed by a human”? What would that qualify as?

Yes, as mentioned by Sean at the start.

I use AI heavily and annotate all commits by provider and model if help was used in any aspect. A similar thing could be done for the software artifact itself. I don't think it's enforceable to require disclosure, but you could hope that some sort of etiquette develops where it's just normal to annotate anything (partially) generated. One could encourage such an etiquette and lead by example.

> Authors that code by hand should have more respect, more funding and recognition by default I don't think it has been true before AI, maybe the opposite in some cases. Before AI you could do a project all by figuring out things yourself or by copying algorithms from a book, snippets from stack overflow or someone blog post, stitching a bunch of other peoples libraries together, etc with different degrees of understanding what's going on. I don't remember respect coming from people assessing how things came to be.

The only place I have seen that give extra respect from handmade stuff and re-inventing wheels is https://handmade.network/, which was more about writing low level stuff, not using libraries or high level languages

> I don't remember respect coming from people assessing how things came to be To a degree, in specific communities. Imagine someone presenting a relatively complex product and saying "I wrote it in assembly from scratch". In quite a few places it would result in a reverent "ooooohhh".

But the opposite is also true. All the papers we love and stuff where you implement something using someone else researched algorithms instead of I did this with my own naive approach.

AI is NOT the same as assembly. I don't know how you can make that comparison.

My point was on the handmade stuff. Like more respect if you figured everything yourself vs using external helpers like LLMs, SO, books, blogs, papers, libraries, etc

Gen AI is a glorified copy/paste monster machine that is destroying jobs and brains, and making our world a much worse place.

I am astonished to read AI assembly comparison in the Clojure slack.

> Gen AI is a glorified copy/paste monster machine that is destroying jobs and brains, and making our world a much worse place. It is hard for me to have technical arguments when we label technology as evil, or monster machines. After that there is no way to follow a technical discussion. I'm not saying it isn't an interesting topic by itself, but I guess it needs its own thread. Otherwise every thread in this channel will be closed with "but it is a monster". What is the point of having a channel just to vent on how evil something is.

"Imagine someone presenting a relatively complex product and saying "I wrote it in assembly from scratch". In quite a few places it would result in a reverent "ooooohhh"." - this is a "capcioso" comment. I cannot find a suitable translation in English.

@jpmonettas, AI and Assembly language are a completely different things technically, aren't they? why are you comparing them?

My point has nothing to do with assembly. But with this idea which I disagree on, that more respect, funding, etc should be given to people that do things as handmade as possible. At least that is not how I judge software creation

> this is a "capcioso" comment. I cannot find a suitable translation in English. "Deceptive"? How so? Nobody compared AI to assembly, you read those comments in the opposite way, pretty much. I was drawing a parallel between "writing without AI" and "writing everything by hand, in assembly".

One again, I'll point to the community etiquette which says you can make technical arguments about how something is made but not diatribes and opinion pieces.

> Many people have done that comparison in here and other places. In that case I haven't seen it. :) AI and assembly are at the opposite ends of all the relevant spectra I can think of, as far as I'm concerned.

I know and I know you know.

@seancorfield, you also share many personal opinions in here.

Why are you so susceptible with AI?

If someone announces a project and it works, and is useful, and you can't tell from looking at the code and docs that it was entirely written by AI - because it is high quality, idiomatic code - what technical argument would you make against it?

Many of us are more open minded and care for both technical arguments and non technical arguments.

> Why are you so susceptible with AI? > That really sounds like an ad hominem comment. You don't actually know my position on AI or how much I do or don't use it.

I am just saying that you have told me not to share my opinions.

Many of us are more open minded

@asier.galdos now you're being snide: the community etiquette says to stick to technical arguments. You can have non-technical arguments elsewhere. That's from Rich and Stu.

Ok, see you. I am off.

I'd say opinions are perfectly fine as long as they don't end up like "specific people should be less respected". :) Without opinions the whole community could become a wiki.

As a person who has used Claude to write something I useful myself I am perfectly happy to disclose whatever is asked for. If you read back this entire thread then to be honest I am not entirely sure I want to publish anything anymore. I feel a lot of passive aggressiveness here that isn't healthy for me

OP talked about trust erosion and requested a policy for disclosure og LLM usage in #C06MAR553. In my opinion it is a good idea to encourage this kind of disclosure as others also have suggested in this thread. I believe there is a range of different (and sometimes subtle) aspects to this trust-dimension, including authenticity, quality, maintainability, commitment, intent, ethics, etc. Several of these dimensions are non-technical in nature. I agree with those who point out that these things can be hard to quantify or categorize/label and even harder to police for admins. But LLM usage can still correlate with several aspects of trust, and a short disclosure of LLM usage in announcements or readmes could probably be of help for potential users who care/worry about these aspects when assessing a new library or tool.

I think we probably all agree that trust and waste of time looking at slop is a problem. The thing is that if it is on admins to announce/enforce some new rules they need concrete actionable ones which have more pros than cons (including admins effort), which has proven so far to be a hard thing.

> I think we probably all agree that trust and waste of time looking at slop is a problem. I'm not sure we can all agree on that -- I haven't had to waste any time looking at slop so far. I've looked at (reviewed) some PRs that are completely AI-generated but not "slop". I guess the projects people have been announcing here that some folks consider "slop" just weren't projects I was interested in learning more about?

Perhaps it could help a bit simply informing that disclosure is important for a subset of community members? Judging from this thread people seem willing to disclose their level of LLM-usage - and maybe many just haven't thought this was of importance to community members?

I'm not sure we can all agree on that -- I haven't had to waste any time looking at slop so far.

I'm having some difficulty keeping track at this stage in the thread, but I interpreted @seancorfield’s original response as coming from a place of concern for health of the community discourse. One of the great things about this community (to me as a relative newcomer) is how welcoming and collaborative it is (and of course the extremely high quality of the work being produced by its members). I understand the concern about maintaining that high quality bar in this new age, but would be concerned having hardline us and them segregation at announcement level would introduce elements of purer-than-thou-ism (or leper-outcast-unclean-ism) that are noticeably absent to date. Perhaps there's a middle ground to be had in community guidelines, where some level of of per-release disclosure of scope of llm-use is recommended as a courtesy to the community? As someone who's spent not inconsiderable time writing assembly and C for embedded software, I wouldn't consider it appropriate to use those tools where I use clojure, or vice versa. Similarly, I prefer to write production clojure code by hand, but am quite happy to engage the LLM's assistance in planning, debugging, third-party library integration, dev-tooling etc. I share the ethical concerns expressed by many here, but maybe a bit less absolute in my views -- I'm dabbling in local LLM use, and trying to build workflows that are portable with a view to medium-term independence from our AI overlords. Hopefully we'd aim for tolerance and mutual respect? It's a shared interest in a relatively obscure programming language and software quality that's brought most of us here, and it would be a shame for this community to be poisoned/divided by this latest hype cycle. EDIT This response wasn't LLM-produced -- it may be repetitive and excessively verbose, but I've just had to come back and correct my grandma... .. and again to correct mi spellingz

I don't think disclosure norms need to matter to a discourse on quality and if LLM generated code is good or bad. No matter where you stand, I don't see the harm in telling people if you used them or not. Let the user judge their own criteria. If you think of the spirit of open source, it's always been about transparency. Show me the source, show me the process. I feel it could be as simple as making posting to announcement use a Slack workflow that asks a few questions when you post and that's that.

This discussion helped me discern at least 3 separate and related concerns: 1. Attribution: who authored the code, contributed to it, as well as who reviewed it. AI should be no different from humans in that respect. However AI is like an omnipotent worldwide developer added to so many teams across the world, often without recognition, that more scrutiny should be welcomed, especially in this age where security concerns increasingly make the headlines. 2. Deontology: just like it is unfair to make somebody else's code appear for one's own, taking AI generated code (a functional unit, not just snippets) and making it appear as coming from humans is called deception, misrepresentation, and at the extreme plagiarism. This is never black and white, we obviously build things on the shoulders of others. More often than not, especially in this community, AI is more of a co-author than a full author. Nevertheless this should be recorded, and the intent to deceive and misrepresent should be palpable to all and remain immoral. 3. Clojurians: what should be the clojurians etiquette regarding AI? This is the concern that started this thread, some would have preferred to keep it focused on that. Personally I find it hard to think clearly about 3/ without reminding ourselves of 1/ and 2/. I'd like to think we all care about 1+2 since long before AI came onto the scene. I don't see why AI should change that, though being such an omnipresent author without being exposed as such raises the question of our acceptable standards and practices. Which is why I think it would be a good idea to make it explicit in the code of conduct to state how AI is used, in whatever way people find relevant, we can refine later if needed. Also I hope our industry standards will improve to better record AI contributions because for now it's not properly recorded as it should.

Related to 1 + 2: AI-generated code cannot be copyrighted (in the US) and therefore cannot legally be published under licenses based on copyright. The US Copyright Office has upheld this in various situations and the US courts have agreed. Just offering that as a data point since not everyone in this thread is based in the US.

Interesting, would that not exclude publishing any AI code under any license? Could that explain why AI remains the unseen contributor then?

People do attach licenses to AI-generated projects, but they should not do so. Even in a project that is mixed human/AI, the license only legally applies to the human portion.

So this makes the question of attribution even more relevant then.

That's why the only project I've published that is vibe-coded uses the Unlicense. It's a throwaway bb script for Calva uses.

Re: attribution -- yes, that's why I mentioned it.

I don't see the harm in telling people if you used them or not

it's definitely something new, and the US copyright law already took a stand on whether it's a tool or not, because if it considered it as a tool it would allow copyrighting AI code

Reading about this I realize it's more about human authorship being the only copyrightable thing

> Speaking for myself I feel like it would be a drain of energy, since I'm not going to label my entire projects as contains LLM stuff I don't understand the "drain of energy"? Like I said, it would likely just be answering a simple drop-down question where you just choose the level of LLM use that you used on the project. It should take like 10 seconds at most to answer it. > So when should the label be applied, because it has consequences like people discarding the entire thing You are being transparent and open, the consequence is that the user can make an informed decision about their comfort in using your project or not, based on their own criteria. How is this a bad thing?

I just dug into the VS Code settings (for those of you using VS Code!)... In the Git extension, it has a setting to add a Co-authored by (AI) if the changes were created by chat or an agent. I think the default is off tho', so you have to manually enable it. I've had that enabled for quite a while, but there are clearly situations where it doesn't detect it so I just updated it to all to see if detects AI code completion (vs regular code completion) and adds the co-author trailer.

(I expected that setting to be part of Copilot, but it's not)

> I don't understand the "drain of energy"? Like I said, it would likely just be answering a simple drop-down question where you just choose the level of LLM use @didibus I don't think that is easy to answer given the consequences. Because if for one version I added a feature for which I used an LLM, I risk flagging whatever I'm announcing as "LLM made" on the announcement channel, when it isn't. Also there are many ways of using LLMs, like for designing, writing tests, fixing some stuff, just one feature, to doing everything. IMHO the only useful labels are "fully made by LLM" or "LLM free", everything else is just confusing labels to add and to consume.

I've tried to ask a couple of times: what level of "LLM-assisted" is enough for folks to nope out of using a project and not got a solid answer. It seems like a weird purity test that no one wants to define.

If your only use of LLMs is in the code completion your editor provides, is that "tainted" for folks? This is why I agree with @jpmonettas that @didibus suggestion isn't realistic.

(right now, I don't even know if there's a way to tell if a code completion suggestion is AI-powered or not -- hence changing that VS Code Git setting to see if adds more co-authored tags)

> Because if for one version I added a feature for which I used an LLM, I risk flagging whatever I'm announcing as "LLM made" on the announcement channel, when it isn't I think as soon as AI was used ever to generate source, it should now count as some level of AI was used going forward, even if the next release you hand wrote fully, the project has some level of AI generated source in it. It seems you are hesitant to disclose this for reasons that it would hurt the popularity of your project, and I get it, you might think you were careful and judicious in your use of AI, that your source is still high quality, etc. and you don't want people to dismiss it blindly on the use of AI, but it seems worse to me to try and hide this in secrecy. We know AI is a hot topic, be transparent and open. The more people see examples of great projects with high quality source disclose their use of AI, and they see that AI was used in them, the more they'll trust projects that use AI, or that it's not really about AI usage, but other qualities that they need to assess projects. > that @didibus suggestion isn't realistic. It would basically just be answering this:

How did you use (or not) AI in this project?

Level 0: No AI at all.
Level 1: No AI written source code, but I used AI to review, lint, generate docs, or help bounce ideas/research.
Level 2: Small amount of AI written source code, mostly restricted to bodies of functions or tests, or in-editor auto-completion.
Level 3: Medium amount of AI written source code, some small features or bug/security patches were fully written by AI, where as major features and critical code paths, were all human coded.
Level 4: Large amount of AI written source code, almost all features, bug/security patches, and code enhancements are written by AI. I fully reviewed every line of it and tested that it works and behave as I'd want it too.
Level 5: Large amount of AI written source code, almost all features, bug/security patches, and code enhancements are written by AI. When reviewing, I only skim overall code structure and critical sections, and test the key behaviors.
Level 6: Large amount of AI written source code, almost all features, bug/security patches, and code enhancements are written by AI. I do not look at the code, treat it as a black box, and only briefly tested the overall functionality at the boundaries.
Other: Tell us: ___________________________________________________________________________

> The more people see examples of great projects with high quality source disclose their use of AI, and they see that AI was used in them, the more they'll trust projects that use AI That is completely counter to what several people have said in this channel. They won't even look at the code if the project says "made with AI" -- and they've said they will trust the author less because of this, so they'll trust that author's other projects less too. That's why we're having this conversation.

If those folks will only accept Level 0, even when Level 4 sounds like high-quality, human-reviewed, and human-approved, then the really seems no point in labeling anything because I think a lot of people are already at Level 2 when you factor in code completion these days, and if you accept even a single AI-authored PR, you're at Level 3.

Yes, because there is a lack of trust, and you don't gain it by deceiving them even more and obfuscating your use of AI. You gain trust by showing transparency, and little by little, having your work demonstrate it maintains a high quality bar, is maintained long term, and is successfully used by others in production. This is a learning process. I personally am at Level 5 on my own projects, and close to Level 6 at work. But I wouldn't trust anyone to be at Level 5 equally, because it depends if they know what they are doing, retained control over the design, semantics, public APIs, have the instinct to know what part of the code is critical and needs more scrutiny, what edge cases need to be validated against, knew the right questions to ask, were able to provide the correct guidance, etc. I think transparency on all those things, so you can actually know what did you do? I see source code and text and other assets, but how can I trust it? Knowing how you steered and validated things, how long you thought through the design, edge cases, etc. How much of the code you are familiar with or hand wrote, etc. I think it's a first step to understand how to rebuild trust and judge AI assisted open source projects.

Declaring AI in projects works for you because you won't automatically ignore any project that is not Level 0. That's why I keep asking folks where they draw the line. If they truly won't look at Level 1 or Level 2 projects, you can't build their trust. Today, they use projects without labels and they are probably already using Level 3 or Level 4 projects but they don't know it. I want to know how they will honestly react if a project they like and use and consider high-quality is suddenly labeled as Level 4?

It seems you are hesitant to disclose this for reasons that it would hurt the popularity of your project, and I get it

Weird situation to be, with reputation of project or author coupled with tool usage

If you realize a bunch of projects you already use and are happy using, and have not found buggy, janky, growing bloated, etc. have been using a ton of AI for a while now, it's a good way to get a signal that maybe you should consider things above 0. Or if you limit yourself to things at 0, and realize nothing is at 0 anymore. And that big projects, like OpenJDK, PostgressSQL, Ring, Hiccup, Re-frame, etc. are all using AI, again you might begin to reconsider. Without knowing, you don't have the feedback data to counteract your opinion.

Or to support the opinion, to be honest, maybe I start to realize a bunch of things I felt were degrading in quality recently, have all began using AI at about the same time. Then maybe I'll reconsider my own opinion down.

@jpmonettas Well, maybe not you personally, but wasn't that your argument against disclosure? Otherwise I might have misunderstood you.

> The more people see examples of great projects with high quality source disclose their use of AI, and they see that AI was used in them, the more they’ll trust projects that use AI I generally agree with this. Projects deciding a way to label this from the ground up sounds really appealing. Having some slack rules requiring AI labeling sounds proscriptive and top down.