I want to remove Claude AI name from Contributor list

[chanupadulnuwan]

🏷️ Discussion Type

Question

Body

I recently rewrote the commit history across all three of my repositories to remove a co-author entry that was added by mistake. I used git filter-branch to strip the Co-Authored-By lines from every commit,
deleted all backup refs (refs/original/), expired the reflog, ran git gc --prune=now, and force-pushed all branches and tags.

The git history is now fully clean — the co-author's name and email no longer appear in any commit. However, the contributor list on GitHub still shows the removed co-author.

Affected repositories:

• https://github.com/chanupadulnuwan/NestleInsight-backend
• https://github.com/chanupadulnuwan/NestleInsight-AdminWeb
• https://github.com/chanupadulnuwan/NestleInsight-mobile

[ahona-omi]

What you can do:

1. Wait a few days for GitHub to reprocess the repository
2. Make a new commit and push to trigger reindexing
3. If it persists after a week, contact GitHub Support

If your commit history is clean (which you’ve verified), then this is just a delay on GitHub’s side, not an issue with your repo.

[muhammadaammaramjad-byte]

How to use AI.

[Uriah08]

Hi There! This is expected behavior on GitHub and not an issue with your git history rewrite.

Even after removing the Co-Authored-By lines and force-pushing a fully rewritten history, GitHub’s contributor graph does not update immediately (and sometimes not automatically at all). This is because GitHub caches contributor data separately from the raw git history.

Why the co-author still appears:

• GitHub aggregates contributors based on past commits it has already indexed
• That data is cached and not instantly recomputed after history rewrites
• Force-pushing does not guarantee immediate recalculation of contributors

What you can do:

1. Wait for GitHub to refresh it
   Sometimes GitHub will eventually recalculate the contributor list, but this can take time and is not guaranteed.

2. Trigger a refresh
   Make a new commit and push it. In some cases, this helps GitHub reprocess contributor data.

3. Contact GitHub Support (most reliable fix)
   If the contributor still appears after rewriting history, you need to contact GitHub Support and ask them to refresh/recompute the contributor graph for your repository.

Include:

• Repository links
• Explanation that you rewrote history to remove incorrect co-author attribution
• Request to refresh contributor statistics

Important notes:

• Your git history is already correct — you’ve done everything properly
• This is a GitHub-side caching issue, not a problem with your repo
• There is no local git command that can force GitHub to update this

Summary:
The contributor is still showing because of GitHub’s cached data. The only guaranteed fix is to contact GitHub Support and request a manual refresh.

[singhrajvardhan]

GitHub doesn’t update the contributor list instantly. It uses cached data, so even after cleaning the history, the old name can still show for some time. Usually, it fixes itself within a few hours or up to a couple of days. You can try pushing a small empty commit to help trigger a refresh, but even that is not always necessary.

If you’ve already checked and the name/email is completely gone from your commits, then there’s nothing more you need to fix in your repo. Just wait a bit. If it still shows after 2–3 days, then you should contact GitHub Support and ask them to refresh the contributor data.

[sangtn13]

Hi,

This is expected behavior on GitHub.

Even after rewriting commit history, the Contributors list may still show the removed author due to cached data. GitHub periodically recalculates contributors, but it can take some time.

You can try:

• Making a new commit and pushing it to trigger a refresh
• Waiting for GitHub to re-index the repository (can take hours to days)

Also note:

• If the co-author had commits previously merged or referenced elsewhere (forks, PRs), they may still appear
• Contributor stats are not always instantly updated after history rewrites

If the issue persists after some time, you may need to contact GitHub Support for a manual refresh.

Thanks!

[RohanBabhale1]

GitHub’s contributor list doesn’t update instantly after rewriting history.

What to do:

1. Wait
   GitHub recalculates contributors in the background. It may take a few hours to a few days.

2. Make sure:

   • No commits (in any branch/tag) still contain that email
   • No forks still reference old commits

3. If it still shows after some time:

   • Open a support request on GitHub
   • Ask them to recompute contributors

Important:

Even after cleanup, GitHub may still show them temporarily due to caching.

✅ Your steps are correct — just need to wait or contact support.

[Gecko51]

The git history is clean on your end, which is the right first step. The contributor graph on GitHub is a separate cached layer and it doesn't update in real time after a force-push or history rewrite.

GitHub caches contributor data independently of commit history, so even after you've removed the commits, the cache may still reference that name for a while.

A couple of things to check:

• Make sure there are no forks of the repo that still have the old commits. If someone forked before your rewrite, GitHub may still resolve that contributor through the fork's history.
• If the repo is public and the name shows in the Contributors tab (not just the commit list), that specific cache can take weeks to refresh on its own.

The fastest path is contacting GitHub Support directly at support.github.com and explaining the situation. They can manually trigger a contributor cache refresh. Just mention that you rewrote the history with git filter-branch and force-pushed, and that the contributor list hasn't updated. They're usually pretty responsive for this kind of request.

[muhammadaammaramjad-byte]

**HI

**

[dannylty]

Rename your "main" branch to "main1" and back (after doing the history rewrite). This fixed it for me.

[AbhinavPabbaraju]

Hey, what you're seeing is expected behavior due to how GitHub computes and caches the Contributors list, which is not a direct reflection of your current Git history alone.

---

Why the contributor still appears

Even after rewriting history and force-pushing, GitHub’s contributor list is derived from:

1. Historical commit data (including previously indexed commits)
2. Cached aggregation results
3. Commits that may still exist in forks, PRs, or hidden refs

So even if:

• your local history is clean
• all branches/tags were force-pushed

GitHub may still show the contributor because:

their contributions were already indexed and cached

---

Important details

1. GitHub caches contributor stats

The contributors graph is:

• not updated instantly
• backed by background jobs

It can take:

• hours → days
  to fully refresh after history rewrites

---

2. Contributions from forks / PRs still count

If that co-author:

• contributed via a PR
• or exists in forks

GitHub may still associate them with the repo.

---

3. Hidden refs may still exist

Even after:

git filter-branch
git gc --prune=now

GitHub may still retain:

• internal references
• cached objects

---

What you can try

1. Wait for re-indexing (first step)

In many cases:

the contributor disappears after GitHub reprocesses the repo

---

2. Trigger activity

Make a new commit and push:

git commit --allow-empty -m "trigger reindex"
git push

This can sometimes force GitHub to refresh metadata.

---

3. Verify no commits remain

Run:

git log --all --grep="Co-authored-by"

and also check:

git shortlog -sne --all

Ensure the co-author is truly gone everywhere.

---

4. If still present → GitHub Support

At that point, it's likely:

server-side cached contributor data

You can contact:
https://support.github.com/contact

Explain:

• history was rewritten
• co-author removed
• contributor still يظهر

---

Important limitation

Even with full history rewrite:

GitHub does not guarantee complete removal from contributor stats immediately or retroactively

Because:

• stats are partially derived from indexed historical data
• and may persist beyond repo-level rewrites

---