Strata's Rewritten Git History to Erase Claude Co-Author Credits Sparks Controversy

How It Started: A Broken Update Script

A developer posted on Reddit alleging that the open-source project Strata had quietly rewritten its GitHub commit history to strip out "Co-Authored by Claude" attributions from commit messages.

The discovery was almost accidental: while running the project's built-in "UPDATE" script, a Git operation unexpectedly failed with a "no common ancestor" error. Digging deeper, the developer realized that every single commit in the project's history had been rewritten, with Claude co-authorship credits systematically removed from commit descriptions.

For anyone familiar with Git, "no common ancestor" is a clear red flag — it means the local repository's commit history has fundamentally diverged from the remote, typically caused by history-rewriting operations like git rebase, git filter-branch, or filter-repo. Normal new commits don't break the common ancestor relationship; only deep rewrites of historical records produce this outcome.

Git's commit history is essentially an immutable chain linked by cryptographic hashes — each commit's hash is derived from its parent's hash. Tools like git filter-branch and filter-repo can batch-rewrite commit content (including messages, authors, timestamps, etc.), but doing so recalculates the hashes of all affected commits, producing a brand-new chain that runs "parallel" to the original history. For anyone who had already cloned the repository, their local copy holds the old chain while the remote has been replaced with the new one — two chains with no shared commit node, hence "no common ancestor." This differs from an ordinary branch divergence: a normal fork still shares at least one common starting commit, whereas after a history rewrite the two are completely independent, and Git has no way to bridge that gap through standard merge operations.

Why This Matters

The person who reported the issue was blunt: "Personally, I find it pretty gross. I can't think of any reason to do this other than to deliberately mislead people about the project's origins."

"Co-Authored by Claude" attributions don't appear out of nowhere. When developers use Anthropic's Claude — particularly coding tools like Claude Code — to generate or assist with code, the tool automatically appends a co-authorship note to the commit message. This is a transparency practice for AI-assisted development, honestly recording the source and process behind the code.

Deliberately rewriting history to erase these attributions is effectively a retroactive cover-up of the project's heavy reliance on AI-generated code. Whatever the maintainers' true motivations, the action itself sends a clear signal: they didn't want the outside world to know about the code's AI origins.

The Transparency Debate: Should AI Co-Author Credits Be Kept?

This incident touches on an increasingly sensitive topic in the open-source community — the disclosure obligation for AI-assisted creation.

As tools like Claude Code, GitHub Copilot, and Cursor become more widespread, more and more code is produced through human-AI collaboration. There are differing views on whether AI attribution should be preserved:

• In favor of keeping it: Attribution records the true creative process and aligns with the open-source ethos of transparency and traceability. Hiding it could mislead users about project quality, maintainability, and intellectual property status.
• In favor of removing it: Others argue that AI is just a tool — no different from using an IDE or compiler — and doesn't need to be noted in every commit. The attribution can feel redundant.

But the core of this controversy isn't about "whether to add attribution" in the first place — it's about retroactively rewriting history to hide attribution that already existed. The former is a style choice; the latter is an integrity issue. Rewriting Git history is an irreversible and disruptive operation that breaks the local repositories of all downstream users — which is precisely why the whistleblower's update script failed.

"Co-Authored-By" is a widely recognized convention in Git commit messages, popularized by GitHub to credit multiple contributors within a single commit. When AI coding tools like Claude Code assist in generating code, they automatically append a line such as "Co-Authored-By: Claude noreply@anthropic.com" to the end of the commit message, recording the AI's involvement in a machine-readable format. The significance of this goes beyond simple copyright attribution: in terms of intellectual property, many jurisdictions have unresolved questions about copyright protection for AI-generated content; in terms of engineering quality, it gives code reviewers the context needed to understand where the code came from and how much to trust it; and in terms of compliance, some organizations' internal policies or open-source licenses have explicit restrictions on the introduction of AI-generated code, making attribution an important basis for compliance audits.

A Practical Warning for Developers

Setting aside moral judgment, this incident carries a few practical lessons for developers who rely on third-party open-source projects:

First, when your git pull or update script suddenly throws a "no common ancestor" error or asks you to force-overwrite, don't simply bypass it with --force or --allow-unrelated-histories. This usually means upstream history has been rewritten, and there may be changes behind it that you need to understand.

Second, a project willing to rewrite its history — breaking downstream compatibility in the process — just to conceal AI origins is itself a reason to question the maintainers' commitment to transparency. When evaluating dependencies, the authenticity and continuity of a project's commit history is an important signal of trustworthiness.

Third, for creators who use AI tools, this serves as a case study in how not to handle AI collaboration disclosures — rather than covering things up after the fact, it's far better to be upfront from the start about the degree of AI involvement in a project.

Closing Thoughts

At the moment, this incident is based primarily on a single developer's account, and there has been no response from the project maintainers, nor much independent corroboration. The specific motivations remain unknown. But the underlying issue it reflects is real and widespread: in an era where AI is deeply embedded in software development, "who wrote this code" is becoming a question that deserves serious attention. Transparency remains one of the most valuable assets in the open-source world.