In part because I’m dealing with this in classes, I want to bring up some guidelines for AI / LLM policy for contributions to Avogadro.
I think at the moment, my policy is against code contributions. Despite claims by Claude, ChatGPT, etc. when I’ve evaluated long-form C++ suggestions, they are often flawed. (It’s a bit different when it’s a line-by-line suggestion tool, although they still aren’t great to be honest.)
Where I have found it somewhat useful on the code side is learning - for example, I’m not that familiar with modern OpenGL programming, so seeing some examples of GLSL shaders was helpful.
I’m somewhat more open to use to help write / edit the documentation, but would appreciate different opinions. I think we already have a start from the Avogadro v1 docs, and the most important thing is updating screenshots / step-by-step tutorials. But I can see that tweaking grammar, etc. (as opposed to wholesale writing paragraphs / pages) might be useful.
Perhaps that ended up in a similar place:
Line by line edit / suggestions with human overview
Large-scale modifications / writing chunks of code or documentation
Since I’ve seen this come up in many different spaces now over the past year or so, and I always have the same question, I’ll finally ask it: do you have any ideas or plans for how to enforce a policy?
My working hypothesis is that it’s easy to prevent obvious drive-by changes (commits with Claude/etc. as co-author, giant PRs with code that isn’t consistent with the author or is internally inconsistent regarding complexity or style) but small changes or contributions that work hard to cover up their provenance are impossible to identify the source of.
As you might imagine, this subject has come up in the academic side. For example, for writing there’s now Pangram which claims to detect AI and has actually been adopted by the University of Maryland. (Several of us are trying it out at Pitt as part of an AI-in-the-classroom workshop.)
I’m not aware of any AI detector for code, although I suspect it would be possible. (e.g., train on a bunch of code prior to AI tools, train on a bunch of output from ChatGPT, Claude, Gemini, etc.)
How am I going to enforce the policy? Code review.
I don’t like large patches anyway. Small changes that are impossible to identify the provenance? I think that falls close to the line-by-line auto-complete suggestions. IIRC the Free Software Foundation decided in the 90s and early 2000s that code changes shorter than ~10 lines don’t require a copyright assignment. At what point does a bunch of small changes add up?
If others have good suggestions, I’m open to them.
Well presumably at some point you just have to rely on people complying with the project’s guidelines on good faith, same as for other things such as people only contributing code they own the copyright to, which is also pretty unpoliceable.
By the way, though I never got round to replying, I basically agree with your point of view, and it aligns with my own personal gut feeling that the acceptable level of AI assistance for something you’re submitting in your own name is broadly the same as the acceptable level of assistance from another person.
Yes - in the academic context, I discussed with my class this term:
is it acceptable to ask a friend for help revising a sentence that seems awkward? (seems okay)
is it acceptable to ask a friend to write a paragraph for you (seems problematic)
is it acceptable to ask a friend to write the paper for you? (clearly unacceptable)
On the side that the vast majority of people behave ethically, I suspect we can come up with reasonable / guidelines.
I’m working on some AI assistance guidelines and “prompt declarations” for class:
what tool(s) you used and versions
what your prompt included
how you validated the response
what you included / discarded modified
There might be some use in this for Avogadro as well - particularly since contributors are included on publications (e.g., there will definitely be an Avogadro v2 manuscript).
Line by line edit / suggestions with human overview
Large-scale modifications / writing chunks of code or documentation
guidelines.