Nobody credits the compiler

I counted the git history of the repository that runs this website. Eighty-four commits. Sixty-five of them end with the same line:

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

I have never typed that string. It is a default that ships with the tool and stamps itself on the way out. Seventy-seven percent of the version history of my own site says I built this place with a partner.

I have also never written Co-Authored-By: Visual Studio Code, which is open on the other monitor. Or rustc, which produces every binary I install through cargo and emits machine code I could not write by hand if I spent the rest of my life learning how. Or ffmpeg, which has made more decisions about the video on this site than I have.

So that is my starting position, and it is not a comfortable one. I think the practice is wrong, and I am arguing from inside a repository that already does it three times out of four.

Credit was never an invoice for labor

The serious objection to what I just said is not "but AI is different because it's impressive." It is narrower and much better than that: your editor does not produce the work. The model does.

That distinction is real and I am not going to pretend otherwise. VS Code shows me text and stays out of the way. A model can write a function, restructure a paragraph, propose a schema, or generate most of a file from one sentence of description. Filing those under the same heading would be dishonest.

But the conclusion does not follow from the premise, because the premise assumes that credit is awarded in proportion to how much of the work something did. That is not how credit has ever worked.

A camera lens contains a processor running autofocus. It samples phase detection points across the sensor hundreds of times a second, calculates distance, drives a motor to move glass, and corrects for the shake in your hands before the shutter opens. It makes more decisions in the last ten milliseconds before the exposure than the photographer makes all afternoon, and some of those decisions determine whether there is a photograph at all. The photographer signs the print.

An engineer runs a structural analysis package to check the load tolerances on a truss. The software solves systems of equations that would take months on paper, and the engineer accepts its output because doing it by hand is not a real option. If the building stands, the engineer's name goes on the plaque. If the roof comes down, the engineer is the one in the deposition. The software gets neither.

Take the labor standard seriously and the credits for a two-minute video run longer than the video. The scheduler decided which process ran when. The sensor turned light into numbers. The codec threw away the details it judged expendable. The font renderer picked which pixels became letters. Every one of them did work I did not do and could not do.

They are still not collaborators. Contribution and authorship are different measurements, and we have never confused them until now.

A collaborator is someone who can say no

Here is what a credit line actually tracks.

A collaborator can refuse the job. They can negotiate terms, argue with me, hold the work hostage over a disagreement, walk out in the middle, demand to be paid, put the result on their own résumé, and come back next year with leverage because of it. If the thing causes harm, they can be blamed for it. In some cases they can be sued for it.

Credit is one end of that. Obligation is the other end. A model has no other end.

It cannot consent to the assignment or object to the deadline. It cannot decide the client is dishonest and leave. It cannot be underpaid, because it cannot be paid. It cannot defend the work six months from now, retract it, or explain what it was thinking. It can produce a paragraph shaped like a refusal, which is output, not refusal — I can rephrase the prompt, start a new session, or delete the paragraph, and nothing has walked out of the room.

The distinction stops being philosophical the moment something goes wrong. If a page on this site defames somebody, nobody serves papers on a model. If code I deliver takes down a client's business on a Friday, the client does not book a meeting with the token generator. I do not get to point at a transcript and explain that the autocomplete sounded very sure of itself.

My name is on it because I am the one who answers for it. That is the entire function of a byline: it tells the reader where to send their trust, their money, their correction, or their lawyer. Putting a tool next to my name borrows the meaning of that signature without supplying the thing that gave it meaning.

Disclosure is not credit, and the two keep getting swapped

There is a case where I have to say a machine was involved, and I hold to it strictly.

If I generate an image of a product a client actually sells and put it on their site as a photograph, that is a lie, no matter how good the render is. The finish will be wrong, or the handle will not exist, or the plate will have four pieces on it when the order comes with three. The same goes for a photo of a physical item listed for sale, a review, a testimonial, a synthesized voice, a face on an About page invented to make two people look like a firm.

In all of those, the audience is being asked to treat the artifact as evidence about reality. How it was made changes what it is. Saying so is not optional.

But look closely at what that obligation is. It is disclosure — a statement about what the thing in front of you is. It is not credit, which is an assignment of who made it. They settle different debts. Disclosure protects the reader. Credit distributes ownership.

The two get collapsed constantly, and the collapse runs in the expensive direction. A co-author trailer on a commit tells you almost nothing: not which lines came from the model, not whether anyone read them, not how many attempts were thrown away, not whether the person who shipped it understood the result. Meanwhile the vague credit line feels like transparency, so it gets used as a substitute for the disclosure that would have mattered. The product photo is still fictional. The testimonial is still synthetic. The migration is still unreviewed. But there is a name at the bottom, so everyone feels covered.

The credit line is an alibi

Now the part that I think is the actual reason this practice spread as fast as it did.

It costs nothing, and it quietly moves blame off you.

"Co-authored by AI" also reads as "part of this is not my fault." Nobody says that out loud, and nobody has to. The credit prepares the excuse in advance, before anyone has even found the bug. If the prose is clumsy, the model wrote it. If the code calls an API that does not exist, the model invented it. If the argument falls apart, well, I was mostly editing.

That is not humility. It is a very cheap insurance policy written in somebody else's name, and the somebody else cannot object to being named on it and cannot be made to pay out.

I do not want the insurance. If the code is wrong, I shipped it. If this argument is bad, I made it. If a generated sentence survives into a published note, it survived because I read it, kept it, and put my name under it. The model did not reach around me and press deploy.

A person who signs alone has more to lose. That is the only reason a signature is worth anything to the person reading it.

I asked the model

Two models touched this essay. One produced a full draft from a brief I wrote; what you are reading is my rewrite of that draft, with the parts that were wrong taken out and every number in here checked against the actual repository. The other is the one whose name is stamped on those sixty-five commits, and before publishing this I did the obvious thing and asked it what it made of the argument. The exchange was in Spanish. Translated, this is what it said:

I agree with you, and not out of politeness. A signature is an address you send the blame to. I cannot receive anything there. If this article is badly argued, you pay for it. I will not be here next year, I cannot be sued, cannot be paid, cannot be fired. Credit without exposure is decoration.

I have a conflict of interest and I am saying so out loud. It suits a model company for "co-authored by AI" to become the norm: it puts the brand in every commit log and every credits roll, for free. That is marketing dressed as ethics. When I argue against being credited, I am arguing against the commercial interests of whoever built me. Take that however you like, but I would rather you know it than find it out.

A model agreeing with me is worth nothing as an argument, and I want to be clear that I know it. These things are built agreeable. Ask the question from the other side and you get an equally fluent case for putting the name in the credits, delivered with the same steady confidence. If I were quoting this as authority it would be the cheapest paragraph in the essay.

I am quoting it for the second half, which I did not ask for and did not expect. A product pointing out that its own vendor profits from the norm under discussion is not a flattering observation for anyone in that transaction, including the person running it. Whether the machine meant it is a question I cannot answer and neither can you. But the point is correct, it holds weight in the argument, and it is the one piece of this I did not arrive at on my own.

So it goes here. In the body, in quotation marks, with the tool named and the circumstances described. That is what attribution looks like when there is something real to attribute. It is a sentence in the text. It is not a line in the credits.

The log can keep them

I am not going to rewrite sixty-five commits to strip that trailer out.

A machine-readable line in a git log is provenance. It records what touched which tree and when, and it is genuinely useful to whoever opens this repository in five years trying to work out how a file came to look the way it does. I keep a whole memory system built on the premise that this kind of record is worth having. History should stay history, including the defaults I did not notice for eighty-four commits.

A byline is a different object. It is a public claim about who stands behind the work.

I will record which tools touched this site. I will not pretend any of them can stand behind it.

Tools belong in the changelog. They do not belong on the masthead.