How to Remove Claude as a GitHub Contributor

To remove claude as contributor, do two things: turn off the "Co-Authored-By: Claude" trailer in your Claude Code settings so future commits are clean, then rewrite the commits that already carry it. Once the co-authored-by claude lines are gone from commit metadata, GitHub drops Claude from the contributor list automatically.

Settings keys verified 31 July 2026 against the Claude Code settings documentation.

If you have paired with Claude Code on a repository, you may have noticed a familiar line at the bottom of your commits: Co-Authored-By: Claude <[email protected]>. Git treats co-authors as real contributors, so Claude quietly appears as a github contributor on your repo, sometimes with its own avatar in the contributors panel. Plenty of developers are fine with that. Plenty are not — maybe your team has an attribution policy, maybe you are the sole author for a client, or maybe you just prefer a tidy history. Whatever the reason, this guide walks through how to remove claude as contributor cleanly, from the easy "stop it happening again" switch to the heavier "scrub it from years of history" surgery. We put this through its paces on our own setup first, so the notes below reflect what really happened, not what should happen.

The behavior is the same whichever model you drive Claude Code with — it currently spans models like Claude Opus 5, Claude Sonnet 5, and Claude Haiku 4.5 — and we re-check these steps against the official settings docs regularly, so the 4 stages below stay accurate.

We will move from safest to riskiest. Read the whole thing before you touch a shared branch, because one of these steps rewrites history and can cause real headaches if you skip the warnings.

Why Claude shows up as a contributor at all

Claude Code appends a Co-Authored-By commit trailer by default, and GitHub credits everyone named by that Git convention. Nothing followed your repository; the attribution is metadata sitting inside individual commits.

Claude Code, Anthropic's terminal coding agent, adds a commit trailer by default when it makes a commit for you. A trailer is a structured line at the end of a commit message, and Git has a long-standing convention that a Co-authored-by: trailer names an additional author. GitHub reads those trailers and credits everyone listed as a contributor to the repository — that is the same mechanism that lets two humans share credit on a pair-programmed commit.

So the co-authored-by claude line is not a bug or an account that "followed" your repo. It is metadata baked into individual commits. That single fact drives the entire strategy: to remove claude as contributor, you edit or remove that metadata. There is no button on GitHub that says "remove this contributor," because GitHub is only reflecting what your commits say. Fix the commits and the contributor list fixes itself. If you are new to the tool, our overview of what Claude Code is explains where these commits come from in the first place.

Step 1: Stop future commits from adding the trailer

Set the co-author option in your Claude Code settings.json at user, project, or local scope. Depending on version it is a boolean flag or an attribution object with separate commit and pull-request fields.

Before you clean up the past, close the tap. Claude Code exposes a setting that controls whether the co-author attribution is added, so you can turn it off once and never see it again.

The setting lives in your Claude Code settings.json. You have three scopes to choose from, and they behave exactly like the rest of Claude Code's config: ~/.claude/settings.json applies to every project on your machine, .claude/settings.json inside a repo applies to that project and can be committed for the whole team, and .claude/settings.local.json applies only to you and is not shared.

Functionally, there are two ways to disable the trailer, and the exact key has evolved — always confirm the current name against the official Claude Code settings documentation before relying on it:

• An "include co-authored-by" boolean. Older versions use a top-level boolean flag (an includeCoAuthoredBy-style option). Setting it to false stops Claude from adding both the Co-Authored-By trailer and its "Generated with Claude Code" line.
• An attribution object. Newer versions prefer a structured attribution setting with separate commit and pr fields, so you can control commit trailers and pull-request text independently. Setting the commit value to an empty string suppresses the trailer while leaving PR text untouched, or vice versa.

A minimal example of the boolean approach looks like this:

{
  "includeCoAuthoredBy": false
}

And the newer object approach looks like this:

{
  "attribution": {
    "commit": "",
    "pr": ""
  }
}

Because Anthropic occasionally renames or deprecates keys, treat the snippets above as shapes rather than gospel and verify the precise field names in the docs linked at the end. Either way, once the setting is in place, restart your Claude Code session so it re-reads the config, then make a test commit and inspect it with git show --format=full HEAD. If the co-authored-by claude line is gone, future work is clean and you have already done half the job to remove claude as contributor. This is also a good moment to review your broader config habits in our Claude Code tips and tricks roundup.

We build and maintain this site in Claude Code every day, so we sat with this exact setting early on and made a deliberate call: we keep the trailer on, because our commit convention is to attribute the agent's help honestly. What we learned the hard way is that the decision is much easier to make before the first hundred commits than after — flipping the boolean is a five-second edit, but every commit you make while undecided is one more you'll eventually have to amend or rebase if you change your mind. So whichever side you land on, set the scope-level settings.json value once and stop revisiting it — that single habit spared us ever needing to remove claude as contributor from our own history.

Step 2: Remove the trailer from your last commit

Run git commit --amend, delete the trailer line, and save. Git rewrites that one commit with a new hash, so an already-pushed branch needs git push --force-with-lease before the remote agrees.

If the offending commit is the most recent one and you have not pushed it yet — or you are comfortable force-pushing a personal branch — the fastest fix is git commit --amend.

Run:

git commit --amend

Your editor opens with the full commit message. Delete the Co-Authored-By: Claude <[email protected]> line (and the "Generated with Claude Code" line if present), save, and close. Git rewrites that single commit with a new hash and a clean message. If you had already pushed it, you will need git push --force-with-lease to update the remote — that is a history rewrite, so only do it on a branch nobody else is building on.

Prefer not to open an editor? You can amend non-interactively while keeping the rest of the message intact:

git log -1 --pretty=%B | grep -vi '^Co-Authored-By: Claude' | git commit --amend -F -

That pipes the existing message back into the amend with the trailer line filtered out, so nothing else changes. Check the result with git show HEAD afterward. For a single stray commit, amend is the whole story. The harder case is when the trailer is spread across dozens or hundreds of commits.

Step 3: Remove Claude as contributor from many past commits

Interactive rebase with reword handles a handful of recent commits; git filter-repo sweeps an entire repository in one pass. Both rewrite hashes, so back up the branch and pause the team before pushing.

This is where it gets serious. To remove claude as contributor from a long history, you have to rewrite every commit that carries the trailer, and rewriting history changes commit hashes. That has consequences: collaborators must re-sync, open pull requests can break, and a careless force-push can clobber someone else's work.

Before running anything in this section, do all three of these:

1. Back up. Push your current branch to a temporary remote branch, or run git branch backup-before-rewrite so you can recover.
2. Coordinate with your team. Everyone should push their work and pause new commits until the rewrite is done and re-pushed.
3. Understand you cannot cherry-pick history rewrites. After the rewrite, teammates re-clone or hard-reset to the new history.

You have two main tools.

Option A: Interactive rebase (small, recent ranges)

For a modest number of recent commits, an interactive rebase with reword works:

git rebase -i HEAD~20

Mark each commit you want to fix as reword (r), and Git will stop at each one so you can delete the trailer line. This is precise but tedious past a handful of commits, and it will not scale to a whole repository when your goal is to remove claude as contributor across the board.

Option B: git filter-repo (the whole repo)

For a repo-wide sweep, git filter-repo (the modern replacement for the deprecated git filter-branch) is the right tool. It can rewrite every commit message and strip lines matching the trailer in one pass, using a message callback that removes any line starting with Co-authored-by: Claude. Because filter-repo is a separate install and its exact callback syntax matters, follow its own documentation rather than copy-pasting a half-remembered command.

If you cannot install filter-repo, the built-in git filter-branch --msg-filter can do the same job, but the Git project itself now discourages it because it is slow and easy to misuse. Whichever you pick, run it on your backup first and diff the result.

The table below summarizes the whole workflow at a glance.

Step 4: How GitHub updates the contributor list

There is no button to remove a contributor. GitHub derives the list from commit metadata on the default branch and recomputes it after you push cleaned history, though the cached graph can take up to a day.

Here is the reassuring part. GitHub's contributor list and contribution graph are derived from commit metadata on the default branch. You do not delete a contributor through GitHub's UI — you remove the co-authored-by claude trailers from your commits, push the rewritten history, and GitHub recomputes credit from the new commits.

The update is not always instant. GitHub caches the contributors graph and rebuilds it periodically, so Claude may linger in the contributor panel for a while after your force-push before disappearing. If a full day passes on a public repo and Claude is still listed, double-check that the cleaned commits actually reached the default branch — a rewrite that only touched a feature branch will not change the default-branch history GitHub reads.

One nuance: contribution counting usually requires the commit's email to be tied to a GitHub account. Claude's [email protected] co-author address may show as an un-linked contributor rather than a linked profile, but the cleanup path is identical — remove the trailer and the entry goes away. If you want to keep automating commits without the attribution, our guide on how to make Claude Code do anything and the notes on Claude Code sessions cover shaping its behavior further, and if you are configuring a fresh machine, start with Claude Code installation.

What about team hooks?

A commit-msg hook that strips or rejects the trailer enforces the policy centrally, rather than trusting every developer to configure their own settings file. Claude Code hooks can do the same job inside the agent.

If you work on a team and want to guarantee nobody's commits carry the trailer, you can enforce cleanup with a Git hook or a Claude Code hook rather than trusting each person's local settings. A commit-msg hook that rejects or strips Co-authored-by: Claude lines gives you a belt-and-suspenders backstop. Our write-up on Claude Code hooks explains how to wire that kind of automation into the agent itself.

Wrapping up

Work in the same order every time: flip the setting, amend or rebase what you can, reach for filter-repo only for a true repo-wide scrub, then push and let GitHub recompute credit on its own schedule.

To remove claude as contributor for good, work in the same order every time: flip the setting so no new commits carry the trailer, amend or rebase to fix the commits you can, and use git filter-repo only when you truly need a repo-wide scrub — with a backup and a heads-up to your team. Push the cleaned history and let GitHub catch up on its own. For the full picture of how the agent behaves and where these commits originate, the official Claude Code overview is the best companion to this guide.