How to Change Git Commit Author in History

Version control systems like Git store important metadata with each commit, including the author name and email address. This information provides accountability by attributing commits to specific contributors. However, you may need to change commit author details for various reasons.

Fortunately, Git offers a simple command to amend the author on existing commits. In this comprehensive guide, we‘ll cover:

• What is a Git commit author and why it matters
• Common reasons for changing the Git commit author
• Step-by-step instructions to modify author information
• How to verify the updated commit author details
• Best practices for responsibly updating commit history

What is a Git Commit Author?

The "author" field in a Git commit records who made the changes saved in that commit. Specifically, it contains the author‘s name and email address in the format:

Author Name <author@email.com>

For example:

Jane Doe <jane.doe@example.com>

Under the hood, Git stores commits as tree data structures that capture file content snapshots and metadata like the author, committer, parent commits, and commit message:

When you create a commit, Git inserts the name value from the user.name Git config setting and email from user.email. This links the changes to your contributor identity.

Git uses this information to:

• Credit contributors for their work
• Identify who introduced changes
• Facilitate communication about changes
• Maintain accountability for changes

The author name and email are permanently embedded in each commit once created. However, Git provides the --amend option to allow modifying existing commits, including author details.

Why Change the Git Commit Author?

There are a few common reasons for needing to change the author on an existing Git commit:

1. Fixing Author Misconfigurations

If Git is not properly configured with your name and email, commits may end up with the wrong authorship.

According to Atlassian‘s 2021 dev survey, around 27% of developers use a shared development machine. And shared machines often contain residual authorship configurations or environment variables that attribute commits to the wrong person.

This commonly happens when:

• Multiple contributors use shared machines
• Developers switch between personal and work accounts
• Author info is misconfigured in GITCOMMITTER* environment variables

For example, this commit incorrectly shows the author as John Doe due to stale settings on a coworker‘s device:

In cases like these, amending the author info ensures it accurately reflects who actually made the commits.

2. Anonymizing Commits

Open source projects allow contributors to submit changes anonymously, identified only by a username. Before sharing code containing identifying details:

You may need to remove personally identifying email addresses from commits to publish anonymously:

There are a few approaches to anonymize existing commit authors:

• Amend the commits locally replacing emails with an anonymous address
• Squash commits into a single anonymized commit
• Rebase interactively filtering identifying metadata
• Create new anonymous commits with fixes

Amending just the author email is typically the simplest option to hide your details before publishing commits publicly.

3. Attributing Changes to Employers

Some employment agreements require that work produced on company time be attributed to the employer.

For example, this clause requires committing with a company domain while working on proprietary products:

Engineers shall use the company email ([email protected]) for commit authorship when contributing to restricted internal projects to clearly attribute work to the company.

Failing to properly assign intellectual property rights with correct authorship could risk legal issues around ownership of code changes. Using --amend ensures commits are properly attributed to the company sponsoring the work.

4. Consolidating Contributed Work

If you incorporate changes from others into your own commits through cherry-picking or rebase, you may want to give proper credit by attributing the consolidated commits to the original authors.

For example, say you rebase a teammate‘s hotfix commit into your feature branch‘s history:

You can preserve original attribution through an amended, signed commit:

In each case, modifying the commit author information maintains an accurate historical record of contributions.

Step-by-Step: Changing the Git Commit Author

Git makes it straightforward to change the author on existing commits with the --amend option. Follow these steps:

1. Navigate to the Local Repository

First, navigate in the terminal to the Git repository containing the target commit:

cd path/to/repository

This allows running Git commands to inspect and modify commits in that repository.

2. Find the Commit Hash to Amend

Next, find the exact commit you want to modify. You can find the commit hash using git log:

git log

This prints out the history of commits. Copy the 40-character hash of the target commit, which uniquely identifies it:

3e43a231751a0e98123ac685e1cc71b5e462ca97

With the hash, you can reference that specific commit when amending:

Optionally, you can amend the latest commit simply using HEAD:

git commit HEAD --amend [args] 

But by specifying the hash, you can modify commits further back in history as needed.

3. Use git commit --amend

To change the author, use the git commit --amend command along with the new --author flag:

git commit --amend --author="New Author Name <email@address.com>"

This opens an editor with the commit message. Simply save and close to keep the existing message unchanged.

Behind the scenes, Git creates a new commit with the same changes and message as the original, but replaces metadata like the author based on the flags passed.

For example, to amend the latest commit author:

git commit --amend --author="Jane Doe <jane.doe@company.com>" 

You can also reference a commit hash to amend commits further back in history:

git commit 3e43a23 --amend --author="Jane Doe <jane.doe@company.com>" 

4. Confirm the Changed Git Commit Author

Finally, check that the author information was properly amended by viewing the commit logs:

git log

You should see the updated "Author" on the commits you modified:

That‘s all there is to it! With --amend you can easily modify commit author details on existing commits locally. Next let‘s go over how to share those updated commits.

Pushing Amended Git Commits

After amending commits locally, you need to force push the branch to apply those changes remotely:

git push --force origin main 

This overwrites the remote branch history to include your amended commits.

However, a force push can cause issues for other developers with commits on the old history. It rewrites project commit logs that may be critical to ongoing work:

So it‘s best to only amend commits that haven‘t been shared publicly.

If you‘ve already collaborated on a branch, consider alternatives like:

• Reverting problematic commits rather than amending
• Creating new commits with fixes to preserve history
• Merging amended commits into a new branch

These strategies prevent you from disrupting other developers just to change an author.

Mitigating Issues from History Rewrites

If you must force push amended commits, take steps to avoid hampering your team‘s work.

First, only update commits that haven‘t been published externally whenever possible. Rewriting public history should be a last resort.

When unavoidable, force push changes during periods of low activity so fewer developers are impacted.

Immediately before overwriting central history, have your team halt any affected feature work and revert to the last known good state:

git fetch
git reset --hard origin/main

This minimizes mid-flight changes disrupted by old commits being removed.

Additionally, notify your collaborators through chat alerts and README updates that a force push is imminent so they can retrieve updates.

Finally, once the amended commits are shared, have everyone rebase any in-progress features onto the updated mainline:

git pull --rebase origin main 

This graft in-progress work onto the rewritten project history, minimizing duplicate and conflicting changes.

With proper coordination, you can limit negative impacts from force pushing altered commit lineages.

Best Practices for Updating Git Commit Authorship

While Git enables history rewriting, amend commits judiciously when working collaboratively. Keep these best practices in mind:

Do‘s

• Do amend only unpublished, unshared commits whenever possible
• Do validate author information before publishing externally
• Do notify your team prior to force pushing public branches
• Do coordinate resets before force push and rebasing after
• Do concisely document reasons for amending commits

Don‘ts

• Don‘t rewrite published commit history without notifying your team
• Don‘t amend commits authored by other contributors
• Don‘t force push during peak team development windows
• Don‘t amend commits already merged upstream

Following these practices helps ensure you only disturb team workflows when absolutely necessary by limiting the scope of changes.

Additionally, never attempt to inappropriately claim or alter commit attribution through history rewriting. Amend commits sparingly with integrity.

Summary

TLDR; Use git commit --amend --author to modify author details on existing commits when needed to fix attribution issues. But avoid rewriting public history to prevent hampering your team‘s work.

In summary, in this guide you learned:

• The Git commit author field associates commits with contributor identity by storing the author name and email
• Common reasons for needing to amend the commit author like configuration errors, anonymization, employment IP agreements, and preserving attribution
• How to use git commit --amend with the --author flag to modify author info on commits
• Force push considerations around rewriting shared commit history
• Strategies for mitigating issues from history rewrites like coordinated resets
• Best practices for judiciously updating commit authorship information

With this knowledge, you can now properly modify commit authors in your Git repository when necessary while avoiding negatively impacting your team‘s collaboration efforts.