A story hit the top of Hacker News yesterday, and it left a sour taste.
Here's the short version: someone asked ChatGPT to generate a New Yorker-style cartoon, and the output came back with the original cartoonist's signature sitting in the corner—identical to the real thing.
This isn't a "looks similar" problem. The model has learned signatures the same way it learned faces and line weight—as ordinary visual features.
The reporting comes from Harvard's Nieman Lab. Original story: ChatGPT Is Adding Real Cartoonists' Signatures to Fake New Yorker Cartoons.
Let's break it down.
The model learned "style" and "signature" as one thing
Style mimicry isn't new. When Stable Diffusion dropped, people joked that you could feed it a name and get "Monet-style" or "Miyazaki-style" images on demand.
But this incident crosses a different line.
What's the most recognizable element of a New Yorker cartoon? Beyond the dense hatching and the cool, slightly off-kilter character proportions, there's the signature in the lower right. Readers see those few marks and instantly know whether it's Barry Bliss or Bob Mankoff.
When a user types "draw a New Yorker-style cartoon about..." the model treats the signature as part of the visual style and reproduces it. It didn't just learn how the artist draws lines—it learned how the artist signs their work.
Technically, there's no meaningful difference between these two tasks.
Why this happens: blind spots in the training pipeline
An image generation training pipeline looks roughly like this:
# Simplified training data processing
def process_training_data(image):
# 1. Load the image
img = load(image)
# 2. Resize to a standard dimension
img = resize(img, 512, 512)
# 3. Random crop
img = random_crop(img)
# 4. Feed to the model
return img
Look at steps 2 and 3. After resizing and cropping, the image becomes a grid of pixel values going into the network. From the model's perspective, the signature, a face, and a background line are all just features.
Current training pipelines have no dedicated step for stripping attribution marks, watermarks, or copyright identifiers. The reasons aren't mysterious:
- Signature detection itself is an open problem. Handwritten signatures vary wildly. OCR models can read printed text, but telling "this is a signature" is much harder than reading "this says what."
- The cost of stripping outweighs the perceived benefit. Adding a dedicated filter means extra annotation, extra compute, and extra risk of false positives.
- Copyright identifiers aren't a filtering priority. Existing filters focus on NSFW content, political sensitivities, and celebrity faces. "The personal signature of a relatively obscure cartoonist" never makes the priority list.
The result: signatures sit quietly in the training set, get absorbed as ordinary visual features, and the model faithfully learns them.
Why this is worse than "AI copying a style"
Starting in 2023, groups of artists filed lawsuits against Stability AI and Midjourney. The core complaint: your model trained on my work, and the output looks like mine, eating into my market.
Those cases haven't been resolved. The legal framework being tested is "style isn't copyrightable, but specific training samples may be infringing."
This incident is different.
In copyright law, the right of attribution stands on its own. It protects against having someone else's name attached to your work. It has nothing to do with whether the style or composition is similar.
Signing someone else's name onto an image you generated means:
- The public assumes the original artist drew it
- Once the image spreads, it pollutes that artist's body of work
- The artist's professional reputation gets bound to content they never made
This isn't "borderline style copying." This is forgery of attribution.
OpenAI's content policy already covers this—it just doesn't enforce it
Here's the ironic part: OpenAI's usage terms already address this.
The OpenAI Usage Policies include the following (check the official page for the authoritative version):
You should not use our services to ... create or distribute content intended to mislead or deceive others about the origin of content, including by representing content as created by a human or other real person when it was not.
Translated: don't use the model to generate content that makes people think a real person made it.
The rule is clear. But enforcement is another story.
When the model generates an image, nothing checks whether someone else's signature ended up in it. There's no check at output. There's no check at training. The policy is just words. By the time a user generates the image and shares it, OpenAI hasn't blocked anything.
The gap between policy and execution is exactly where this incident happened.
Practical fixes: signature stripping, style decoupling, provenance watermarks
There are real technical directions here—not just wishful thinking.
1. Strip signatures before training
Add a detector to the data cleaning pipeline that flags signature regions in images, then masks or crops them out before the data enters training.
from PIL import Image
def strip_signature(image_path):
img = Image.open(image_path)
# Check the bottom-right region (where signatures typically live)
sig_region = img.crop((img.width * 0.7, img.height * 0.85,
img.width, img.height))
if is_signature(sig_region):
# Fill the signature area with background
img.paste(fill_background(sig_region),
(img.width * 0.7, img.height * 0.85,
img.width, img.height))
return img
The hard part: signatures don't sit in fixed locations. Some cartoonists weave them into the linework, others mix them with watermarks. Building a reliable detector is its own engineering project.
2. Force style-transfer to decouple attribution
Get the model to split "style" into independent dimensions: linework, color, composition, signature. At generation time, the user picks "linework style only, no signature."
There's technical precedent for this in LoRA training and adapter fine-tuning. The real question is how to define "signature" as a decoupled dimension. In today's latent space, these things are tangled together.
3. C2PA provenance metadata
The C2PA (Coalition for Content Provenance and Authenticity) standard handles content provenance. The mechanism is straightforward:
// C2PA metadata example
{
"claim_generator": "OpenAI/DALL-E",
"assertions": [
{
"label": "c2pa.actions",
"data": {
"actions": [{
"action": "c2pa.created",
"softwareAgent": "DALL-E 3"
}]
}
}
]
}
Generated images carry metadata declaring "this is AI-generated, not the work of some artist." Adobe, Microsoft, and OpenAI have all signed on.
But here's the catch: the watermark lives on the client side. The moment a user takes a screenshot, the metadata is gone. That's a technical problem, a product problem, and a legal problem.
Editorial note
The alarming thing here isn't that a model copied someone again.
The real issue is that forgery of attribution is becoming a low-cost default behavior.
As long as nobody complains, the model will keep signing. No complaints equals most of the everyday traffic. Everyone has asked a model to "draw in the style of [some painter]" at this point. Few realize the output might come with a signature attached.
There's a fundamental difference from the earlier "AI copies your style" wave. Style imitation is a gray area. Signature reproduction is a red line. Copyright law treats the right of attribution as its own protected category, and this incident is "attribution forgery"—a legally distinct thing from "borderline style copying."
The next real battleground isn't verbal bans at the generation layer. It's the training data side.
Specifically, three things need to happen:
- Training pipelines need signature-handling steps, with priority on par with NSFW filtering
- C2PA metadata needs to be the default, not optional
- Violations need to be traceable—given an image, trace it back to the model and API call that produced it
OpenAI's usage policy can read as polished as it wants. It won't stop the model from silently generating signatures. Technical interception can't be replaced by policy statements.
To be clear, signature detection is itself an unsolved problem. Handwritten signatures are wildly varied, and false-positive rates could be high. Whether model vendors will invest in this relatively niche issue is a separate question.
But the roadmap is clear. The bill for this is going to come due at some model vendor's door.