How to Change Your Last Git Commit Message

You just made a commit, and then you spot a typo in the message. Or maybe the message says “fix stuff” when it should clearly explain what you changed. It feels frustrating, but it is also very fixable.

Git lets you rewrite the message of your most recent commit in seconds, as long as you know whether you have already pushed it or not. That one detail changes the safest method.

In this guide, you will learn the simple amend command, how to fix a message in your editor, and how to handle the situation carefully if the commit is already on GitHub.

Quick Answer

To change the message of your most recent commit, run git commit --amend -m "Your new message" if you have not pushed yet. If you already pushed, amend the message locally and then update the remote with git push --force-with-lease, but only on a branch that no one else is using.

Why Commit Messages Matter

A commit message is a short note to your future self and your team. Months later, when you search history to understand a change, a clear message saves you real time.

Good messages explain what changed and, when needed, why it changed. Vague messages like “update” or “changes” give almost no useful information.

Common reasons to fix a message include:

• A spelling mistake or wrong word that makes the message confusing.
• A message that mentions the wrong file, feature, or issue number.
• A message that is too vague for teammates who review the history.
• A missing detail, such as a ticket reference your team requires.

Fixing the message right away is good practice. Just remember that amending creates a new commit with a new hash, which is why pushing history needs extra care.

If you are still building your Git foundations, our step-by-step GitHub beginner guide for your first projects covers commits, branches, and pushing in a simple order.

Before You Amend: Check Two Things

Take ten seconds to check your situation before you change anything. This small check decides which steps are safe for you.

1. Run git log --oneline -3 to see your recent commits and confirm the message you want to fix is the latest one.
2. Ask yourself if you have already run git push for this commit. If you are unsure, run git status and read its message about your branch and the remote.
3. If git status says your branch is ahead of the remote, the commit is local only and amending is simple and safe.
4. If the branch is up to date with the remote, the commit was already pushed, and you should follow the pushed-commit steps later in this guide.

The amend command only works on the most recent commit, usually called HEAD. Older messages need an interactive rebase, which is a more advanced topic covered briefly at the end of this article.

How to Change the Last Commit Message (Not Yet Pushed)

This is the easy and common case. Your commit exists only on your computer, so rewriting its message affects nobody else.

Method 1: One-Line Amend Command

1. Open a terminal in your project folder.
2. Run git commit --amend -m "Your new clear message", keeping the quotes around your message.
3. Run git log --oneline -1 to confirm the new message appears at the top.
4. Continue working as normal, or push with git push when you are ready.

For example, to fix a vague message you could run git commit --amend -m "Fix login button not responding on mobile". Your code does not change at all. Only the message, and the commit hash, are new.

Method 2: Amend Using Your Text Editor

If your new message needs several lines, use the editor method instead. It is also the best way to add a longer description below a short title.

1. Run git commit --amend without the -m flag.
2. Your default editor opens with the old message inside it.
3. Edit the message. Keep the first line short, leave a blank line, then add details if needed.
4. Save the file and close the editor. Git completes the amend automatically.
5. Verify the result with git log -1, which shows the full message.

The official Git commit documentation explains the --amend option and related flags if you want the full technical reference.

Can You Also Add Forgotten Files While Amending?

Yes, and this is a handy bonus of the amend command. If you forgot to include one small change in your last commit, you can add it at the same time as fixing the message.

1. Edit or fix the forgotten file as needed.
2. Stage it with git add filename.
3. Run git commit --amend -m "Your new message" or git commit --amend --no-edit if you only want to add the file and keep the old message.
4. Check git show --stat HEAD to confirm both the file and the message look right.

The --no-edit flag reuses the existing message, saving time when it was already fine.

How to Change the Message If You Already Pushed

If the commit is already on GitHub or another remote, amending locally creates a mismatch. Your local history now differs from the remote history, so a normal push will be rejected.

You can still fix it, but you must follow two rules. First, only do this on a branch that belongs to you alone. Second, warn any teammate who might have already pulled that commit.

1. Amend the message locally with git commit --amend -m "Your new message".
2. Run git log --oneline -1 to double-check the new message.
3. Update the remote with git push --force-with-lease origin branch-name, using your real branch name.
4. Refresh GitHub and confirm the new message appears in the commit list.
5. Tell your team you rewrote history, so they can update their local copies correctly.

Prefer --force-with-lease over plain --force, because it refuses to overwrite the remote if someone else pushed new commits after your last fetch. It is a simple safety check that prevents real accidents. GitHub explains this approach in its guidance, and the official GitHub guide to changing a commit message covers both local and pushed cases.

On a shared branch like main in a team project, the safest choice is usually to leave the message alone. A slightly imperfect message is far better than a broken history for your whole team.

What About Changing an Older Commit Message?

The amend command can only change the very last commit. If the message you want to fix is two or three commits back, you need interactive rebase.

In short, you run git rebase -i HEAD~3 to list the last three commits, change the word pick to reword next to the target commit, save, and then edit its message when the editor opens again. After that, you finish the rebase and force-push only if the commits were already shared.

Interactive rebase is powerful but easier to get wrong. Practice it first on a test repository.

Common Mistakes to Avoid

• Amending a commit that is not the latest: git commit --amend always changes the most recent commit. Check git log first so you do not edit the wrong message.
• Force-pushing a shared branch without warning: Rewriting public history can break your teammates’ work. Always communicate first, or skip the fix on shared branches.
• Using –force instead of –force-with-lease: The lease version protects you if a teammate pushed in the meantime. Make it your default habit.
• Forgetting the quotes around the message: Without quotes, your shell may treat parts of the message as separate commands. Always wrap the message in double quotes.
• Assuming the code changed: Amending a message does not change your files, but it does create a new commit hash. Old references to the previous hash will no longer match.
• Writing a worse message in a hurry: Take a moment to write a clear, specific message. That is the whole reason you are fixing it.

Conclusion

Changing your last commit message is quick with git commit --amend -m "New message", and it is completely safe when the commit has not been pushed yet. Use the editor method when your message needs more detail.

If you already pushed, think carefully, use git push --force-with-lease only on your own branch, and warn your team. With that simple care, you can keep your project history clean and easy to understand.

Frequently Asked Questions

Does amending a commit message change my code?

No, your code stays exactly the same when you only change the message. Git creates a replacement commit with the same file changes, a new message, and a new commit hash.

What does git commit –amend –no-edit do?

It amends the last commit without opening the editor or changing its message. Developers use it to add a forgotten staged file to the previous commit while keeping the original message.

Why was my push rejected after I amended the message?

Because your amended commit has a new hash, your local history no longer matches the remote history. On your own branch, you can resolve this with git push --force-with-lease.

Can I change the message of a commit that is not the latest one?

Yes, but not with --amend. You need an interactive rebase with git rebase -i HEAD~n, marking the commit as reword. It is more advanced, so practice it on a test project first.

Is it safe to change a commit message on the main branch?

If the commit was already pushed and teammates use that branch, it is not safe without team agreement. Rewriting shared history forces everyone to fix their local copies, so most teams avoid it.