How Claude marks AI-generated content

I've long thought we would have some sort of verified-point-of-origin for data using a hash or cryptographic seal of some kind. I don't know the precise technical language for that but some metadata traveler that can verify the data has not been edited after creation.

For straight generated code it'll likely need more text, but it'll still show up.

In cases where one token is extremely likely, it'll randomly be red or green and still be picked in either case as it is simply the best (or only) option. So you'll have more tokens that don't show a pattern either way (half of these cases will match and half won't, just the same as if a human wrote it). Meaning you'll need more instances where multiple tokens were all likely to see if there is a pattern. Given the check algorithm can't identify these cases, it can only judge on the overall text, so the more strict a language, the more the length requirement scales.

Where I wonder if this keeps working is in tool calls. Often, you don't take code straight from the llm, you take the results of a tool call to edit already existing code. It might be that the result of this leads to far too few signals to pick up, meaning that this only works when one does significant generation with a single model (even swapping between different models, at least by different companies, breaks this just as much as having a human write parts of the code).

Think of it like finding a loaded dice. A dice that has a slight bias in a few dozen roles is just random chance. If that bias continues after hundreds of thousands of roles, the dice is loaded. But will a code base have enough samples, especially when edits made from tool calls? I could see this being unable to detect things at the size of a reasonable PR and only being useful for massive sets of changes and only if the person behind them didn't structure their AI usage to avoid detection.

It's not up to Anthropic.

Rate limits, presumably.

Huh... I wonder if some big version of a bloom filter would work as well. Hash all output text, probably in chunks of a couple tens of tokens each (that would need tweaking to find the most useful hash input length I guess), and smash 'em into a bloom filter. Every month or something, Anthropic releases a giant file containing whatever huge length of bytevomit would have to be used to get an acceptable false positive ratio. (In terms of bloom filters! Meaning: still far from a perfect ratio.) Maybe one for each model they provide or something?

Then at least you could have two weak-postive signals, and a strong-negative signal. (Though one that only fits precise chunks of tokens) I'm sure I'm missing something here, but my groggy morning brain thinks that doesn't seem too bad.