Don't credit the LLM | Hacker News Reader

Don't credit the LLM

isaacsu.com

35 pointsisaacsu48 comments

There is a difference between crediting the LLM (which i agree is silly) and disclosing the use of an LLM, which I think is important. The author seems to conflate these two.

A disclosure is appropriate whenever the reader might feel differently about the result of armed with this information. For example, "this research on the non-addictive nature of tobacco, funded by the tobacco industry".

Moreover, not citing the LLM is plagiarism. Maybe people outside academia have an oddly narrow understanding of plagiarism, and (for example) cannot understand how it is possible to plagiarize yourself. It is hard to explain the importance of citing LLM contributions to people with this view.

Disclosure is appropriate when a reader might feel differently. A reader such as, oh, a judge in a courtroom.

> not citing the LLM is plagiarism

Using an LLM to substantially generate the output rather than just make tweaks to one's own work is plagiarism; not citing the LLM is neglecting to admit to plagiarism.

> Why did I need to know that?

In a perfect world such a disclaimer would help anyone reading the output by setting expectations. We each have different experiences with this, and different levels of acceptance. Knowing that something is using generated content can help anyone either accept / skim / thoroughly review something.

The problem is that we're seeing lots of backlash, often for ideological reasons, or for outdated somewhat technical reasons, so people have less of an incentive to be honest, and tons of incentives to hide their use.

Agreed.

No one minds when I credit a fuzzer for finding a bug. I hope we can use the same pragmatic attitude for LLM help.

Pragmatically, the range of application for a fuzzer and for an LLM are so widely different that I'm not sure it makes any kind of pragmatic sense to compare the two.

Also, I don't hear a lot of people credit fuzzers. I do hear a lot of people say things like "we are fuzzing the code"'just like they say "we are hammering the nails" and not "wow hammer great job getting that nail in place"

> so people have less of an incentive to be honest, and tons of incentives to hide their use

Case in point, the recent Hank Green incident. That was an own-goal of being too honest about LLM use and I suspect the industry learning will be "don't talk about the process." Larian Studios got in hot water earlier over a similar "we may use AI in preproduction" incident.

Why did I need to know that? To tell whether your contribution is compatible with our project's chosen redistribution license, and contribution policies.

> 1. You believe in ascribing credit where credit is due. Using an LLM feels like cheating so disclosing it makes you feel less like an imposter for having produced something amazing.

Cheating isn't the right word here. Crediting LLMs is about giving everyone involved accurate information which can be used for later decision making (e.g. if something unexpected happens as a result of a LLM-ism).

An LLM is not me. It is capable of doing more "work" but it also doesn't have my mental models and experience. My colleagues know roughly my areas of expertise. If I say "I think that X is happening" they'll assume that is the result of my expertise being applied and react accordingly. If I say "[LLM] thinks X is happening" they'll react differently and I want them to. Just like I might say "I suspect X is happening because Y" or "X is definitely happening" when I want to modulate their trust in what I'm saying.

the phrase "[LLM] thinks X is happening" is good chunk of the problem

it didn't. it produced an output, and you hopefully invoked some human judgement before believing it was worth sharing, and you are hopefully expecting to be accountable if that judgement was incorrect (whatever the failure mode)

You must be fun at parties

Fine. "The LLM produced a chain of reasoning consistent with a belief that X is happening."

I've found it fairly helpful to anthropomorphize systems to communicate things about their behavior, despite them obviously not being human ("The load balancer thought the West US region was chilling", or "that cluster was unhappy because of bad packet loss"). I don't really have many problems with people taking those statements that I think computers have emotions.

This is a little silly — if I quote a large passage from an encyclopedia (or whatever), I cite the source. If I use an LLM to write some of a paper or report, I’m not writing that part (even if I edit it or rephrase it or whatever) so I’d better credit the LLM in whatever way is most consistent with how its output is being presented in the paper.

I think there is a clear distinction to make in the case of communications.

Yes, if you are writing a longer piece of communication and you just verbatim ship whatever the LLM spits out, it is important that you note that in the communication. This obviously applies to deepfakes as well.

But this quickly gets slippery. If an LLM generates an initial draft of a paragraph, and I edit it 10 times making mostly stylistic changes, do I need to cite the LLM for that passage? How much personal touch is enough to absolve one of LLM citation? We don't require filmmakers to present a "this is CGI" banner during films (only occasionally in trailers), if a filmmaker uses an LLM to generate 20% of the contents of a film, much in the manner of CGi usage, do they need to add a disclaimer?

The text produced by an LLM really doesn't function the same way text produced by humans does. The cited human is a stable entity that exists, not a stateless machine. You can ask them about their quoted work, look up their history, etc. There is a stable participant in the field with a stable identity that you can talk to. Not so for LLM produced text.

At the end of the day whatever it is your present is coming from you. Own it. If you feel the need to hedge that such and such was from an LLM it probably means that it's bullshit that you'd better rework or at least understand much better before you pass your slop off to some poor coworker

> If an LLM generates an initial draft of a paragraph, and I edit it 10 times making mostly stylistic changes, do I need to cite the LLM for that passage?

How much stylistic change removes the citation requirement from large blocks of someone else’s text in an academic paper?

The ideas in the paragraph continue to be plagiarized out of the training data of the LLM, in spite of stylistic changes. The paragraph was essentially composed by an interpolative mashup of the works of unknown, unidentified authors.

If you take an initial draft of a paragraph from someone else’s work and reframe it into your own wording, that is considered plagiarism unless you properly attribute the original source. You should follow the same guidelines for the llm. I agree that you should also make sure you understand and believe what you wrote. None of this is very slippery — understand the ideas you present and don’t pretend to have come up with ideas that originated elsewhere.

At work I recently credited Claude with writing some of the tests in my PR. Why? Partly to apologize for the verbosity of the tests making them harder to review. Partly to set expectations: the tests are more likely to be buggy, low-quality, or incomplete, or misunderstand the code being tested, than if I had written them by hand.

I did in fact "bother to review" the tests, and I thought they were good enough to merge. Indeed, they were better than what I would have written on my own: they were lower-quality on a line-by-line basis, but for tests, quantity is a quality of its own, and I would not have bothered to write nearly as many tests. Even so, it was worth flagging that Claude wrote them.

If I trusted LLMs more, would I still feel the need to credit them? Maybe. They are improving very quickly, and I think they will eventually improve to the point where a mostly-LLM-written PR will be as good as mine in every way. Then it will no longer be necessary to apologize for submitting LLM code. But if and when that point is reached, I wouldn’t get used to taking credit for said code! Because it probably won’t be much longer until the human in the loop becomes redundant.

Going back to today, I don’t feel the need to credit LLMs when I use them for tasks that don’t involve submitting their output. In particular, they have recently become quite good at finding bugs in my code.

> Odd. Like a writer disclosing the spellchecker they used alongside every piece,

No it’s not. A spell checker tells me if I misspelled any of my own words.:!it doesn’t write for me.

> or a pilot announcing their version of avionics software over the PA while taxiing to the runway.

No, it’s nothing at all like those things. It would be more like your pilot letting Claude direct his taxiing.

People disclose LLM involvement because they know they didn’t really* author that output, and they want to disavow responsibility for it being totally wrong. Even if I just need a quick figure and I google it, I still disclose that I googled it rather than pulling it out of my own expertise.

It’s #3, it’s a disclaimer, you’re helpful if it’s right and not to blame if it’s wrong.

When I see it, it always makes me want to respond “weird, I asked Claude too and it said <different answer>”.

I don't see like that, for me it's like: here's an approximate answer. Is that sufficient or do you need a 100% accurate number? I can get this info for you, but I will have to stop everything I'm doing right now to figure it out or do it after I'm done with other priorities.

Sometimes the person asking just needs an estimate, a ballpark number. It doesn't really make a difference if 17 or 18 support requests were received.

That’s important to know too though. Most people are still figuring out this new world and knowing where it breaks it pretty critical right now.

#3 just means the person is going to stop asking you when they realize that:

a. You bring no expertise beyond asking an LLm for the answer. b. They can just do that themselves.

If someone is asking you something and you tell them "this is what the LLM said" you're doing it wrong. If they are asking you they assume you possess some kind of acumen you can use to do better than they can blindly following an LLM and if you can't, well, why are you even involved in this interaction?

Personification an LLM has become a style or trend. Saying "Sol solved this problem for me" sounds great, indicating your honesty in giving credit to LLM. However this is wrong. You are "using" LLM to solve something, just like "using" a calculator to do some computation. Still the computation is done by you, not calculator. When you drove from X to Y, you did it, not the car.

Can we still say things like "GCC eliminates the dead code for us so we can leave it written this way", like we did decades ago, or where are the goalposts?

> When you drove from X to Y, you did it, not the car.

Really? Even if it's a self-driving car where you just punched where you want to go, into an app?

My read:

Isaac Su seems to be irritated and mildly triggered that people don't think or act like LLMs aren't just dumb, mute, simple tools.

Instead of talking about THAT, he is doing a weird combination strawman/bikeshed-like post about the different imagined, nuanced reasons why he imagines people credit LLM input in attribution.

A more honest take would be:

"Some of you are ascribing more sentience and agency to LLMs than I feel comfortable with. Stop doing that. I'm obviously and fundamentally right that they are dumb tools that can never threaten my intellectual and emotional security or human superiority."

Whether they are right or wrong — one reason that many people are giving credit is that they feel that (at some at level at least) that Claude/DeepSeek/Gemini/etc. is acting enough like a participant or partner to deserve being given credit.

You should cite your sources, and that might include an LLM.

If you use AI chat as a search tool and then read whatever web pages it finds to check them for yourself (as you should), then you can cite that instead.

Citing an LLM is a sign that you couldn't be bothered to do that, but at least it's honest.

Including AI contributions in your work is curation of its outputs. Should a museum or gallery pretend the works in their exhibits were made by them? Of course not. Cite where you got things from.

I completely agree. All crediting LLMs does is give the companies that built them precisely the kind of ego stroking feedback they want. I bet Dario giggles with excitement every time he sees "Claude" as the author of a git commit. People are feeding directly into y heir narrative that these tools are not tools but somehow replacements for human beings.

You piloted the LLM, you are responsible for the code. I don't sign my commits with "autocompletions by Intellij". This whole thing is nonsense.

As for the possibilities listed in TFA, I personally think the most common one is people just blaming the tool or hoping to use citation as cover for slop work. It's basically an admission of "I didn't look into this as thoroughly as I myself think I should have to really understand what I'm doing". Don't be that person. If you don't understand what you are doing prompt the LLM with questions until you do understand. It isn't difficult.

Yes, it just a way to remove responsibility in case of problem. Very bad attitude. Whether the code comes from an autocomplete, a LLM, the documentation, a Stack Overflow response or has been 100% typed with your fingers doesn't matter: you're the one in charge.

Sometimes AI's contributions may be diffuse, and more akin to the suffusion of a tea-bag, or even a drop of tincture, than the addition of an extra cookie on the plate. In such cases there is usually no distinct section that you can wall off and say 'AI did this'. In spite of this, it may have made a rather modest than overwhelming contribution to the work.

You compare LLMs to spellcheckers, but they are clearly very different in capability at this point. These agents are becoming more human-like and "just a tool" is no longer a fair characterization.

And even if you believe it's just a tool, a text generator that takes in and spits out the Internet, you should cite it like citing a website.

So many comments in here are missing the point.

By not crediting and personifying the LLM, one (re)takes full human responsibility over the produced works and stated claims. As a result one won’t become an “agent” for the LLM.

The title could have been Don’t blame the LLM.

When we first started using LLMs professionally it was fine to hide behind disclaimers. Now with widespread adoption it’s time to step out of the LLM’s shadow and take credit/blame again.

This whole discussion is a result of Claude using "Co-authored-by" as advertisement because it massively propagates the Claude logo to GitHub. As an advertisement strategy, this is extremely impressive.

Unfortunately, it conflates what's meant by co-authoring. Because so far, Claude has not claimed sovereignty as an artificial intelligence, so actually, mentally crediting Claude is like crediting Vim or Emacs.

We don't have to think of our tools as being authors just because Anthropic did.

The Co-authored-by had a real meaning related to accountability.

Putting our tool in front of us is like letting our cat drive the car. I mean, it's fine if it sits in our lap with the paws on the wheel wearing sunglasses. Just don't pretend it is the one deciding the direction, taking critical turns. Because when we get pulled over, the cops aren't gonna buy it. And neither is anyone on GitHub. We know Claude is still just a program.

On a lighter note: it’s perfectly fine to take full credit for caring about a problem.

I agree but not for the reasons the article states. If you say “an LLM made this” and are proven to be wrong, then you can divert blame to the LLM: this is bad as you don’t in the future try to improve yourself and verify the LLM.

You are the author of something created by an LLM in the same way you are the winner of a chess game while using a chess engine to make the moves.

I'm always skeptical of a recommendation to a technical problem when someone tells me they used an LLM chatbot like CoPilot. They really are just slot machines. Sometimes the answer works. Sometimes it doesn't. On the other hand, when someone tells me they googled it and found an article - not that AI overview crap - I trust it more because I know it was written and tested by a human.

I find human answers and handwritten code to be much worse of a slot machine. An article (or stack overflow post) has a not-insignificant chance to be riddled with outdated API calls, human-made bugs, unspoken assumptions of knowledge on my part or how the environment it runs in will be set up, etc. Meanwhile a frontier model easily deals with all that for you and gives you something that almost always just works, tailored to your exact requirements, with thorough test cases and validation that it works before handing it off to you. By the time you've hit roadblock number 4 out of 20 trying to adapt that human slop to fizzbar 2.0 because 1.9 was deprecated, the LLM would have been done.

"Googling" is pretty dead to me. Frontier model agents give much better, tailored to your case, answers. And it's faster. And there's no ads.

Taking credit for something you didn't do, whether it was done by another person or by an LLM, is dishonest and unethical. Prompting an LLM to create something is obviously not the same thing as creating it, and I feel this article is trying to normalize tacit plagiarism. In most contexts I'm aware of where assigning credit actually matters, human authorship and LLM authorship are very much distinguished, and failing to "credit the LLM" in some cases can even have legal consequences.

(You don't have to mention LLMs every time you use them because sometimes the credit really doesn't matter.)

> But for the first reason, I’d challenge the notion of sharing credit with a tool, let alone feeling like a cheat for using one.

That's the main reason LLMs aren't "just a tool."

> Credit and accountability are two sides of the same coin. A tool can only take as much credit as it can be held accountable for, so crediting it inadvertently dilutes your own accountability for the work.

Huh? No, credit and accountability are pretty orthogonal. I use tons of open-source tools, and everyone agrees that the respective authors get credit for what they made, but only I am accountable for my use of them. In fact, all open-source licenses spell this out explicitly.

If I plan a project to build an app and write the full technical specifications and architecture myself, draft data structures, and even provide logic suggestions, and then hand it over to a team of humans to implement - it is at least my teams work. A case can be made that it still primarily my own work (no one expresses much issue with the title: Sid Meier's Civilization as an example).

If I have a large amount of capital to burn, and an idea that begins and ends with 'build me a Groupon clone for x market', then just pour money into a team of outsourced humans at a software sweatshop to build it. Is it still my work? Again, not many people would object if I were the face of that company, it is after all my app.

I'm struggling to see what the difference is if humans were swapped with LLMs in each case? Is the issue that the LLM models were trained on plagiarized code? I agree we should take issue this aspect, but when it comes to being honest about credit for the 'doing' part, this has never been the case, pre or post LLMs.

I don't understand this rebuttal at all. There is a huge difference between having an idea and implementing it yourself, and handing your idea (plus suggestions and data structures or whatever) to other people to implement. In the latter case, the team completing the project gets a lot of credit for the work. That has certainly been the case everywhere I've worked, and I wouldn't have it any other way, even in cases where I was more of the concept guy. I haven't played Civilization, but I'm sure if you play it to the end, you'll see a nice list of people who worked on the game, not just Sid Meier.

So are you saying we should have a credits doc for all major contributors to all software and hardware products, both human and LLM? I'd agree with that, this is not available at the moment for the most popular and profitable products in use currently.

I do credit all contributors to my open-source projects, and I think this is the norm, but to be clear (and I did say this in my original comment), I'm only talking about cases where assigning credit is actually important. There are many cases where it isn't.

I think people do this because they’re hedging and to be transparent

I'll definitely credit Isaac for his eloquent, non-slop writing style. Tried to start a related discussion lately (https://news.ycombinator.com/item?id=49027642) more focused on the identity of developers in the age of the agent's second or first authorship.

paper submissions require LLM disclosure

Reply on news.ycombinator.com