Introduction

If you forgot to include a file in your most recent Git commit, the normal fix is to stage the file and amend the last commit. That rewrites the commit object so the file becomes part of the latest snapshot, which is convenient locally but important to handle carefully if the original commit was already pushed.

The Normal Workflow

First stage the missing file.

git add path/to/file

Then amend the last commit.

git commit --amend

Git opens the commit message editor and lets you confirm or change the message.

If you want to keep the exact same message, use:

git commit --amend --no-edit

That is the shortest answer to the question.

What Amending Actually Does

Amending does not mutate the existing commit in place. Git creates a new commit object with:

• the previous commit's parent
• the updated snapshot
• the amended metadata or message

Because it is a new commit object, it gets a new commit hash.

That matters because anything that already points to the old commit, such as a remote branch other people have pulled, will now disagree with your local history.

A Concrete Example

Suppose your last commit missed README.md.

git add README.md
git commit --amend --no-edit

You can verify the result with:

git show --stat HEAD

The amended commit now includes README.md in the latest snapshot.

If the Commit Was Already Pushed

If you already pushed the original commit to a shared remote, amending it rewrites published history. That is not automatically wrong, but it changes the coordination problem.

To update the remote branch, you usually need a force push.

git push --force-with-lease

Use --force-with-lease, not plain --force, unless you have a very specific reason otherwise. It adds a safety check so you do not overwrite remote work you have not seen.

If teammates may already have based work on the old commit, communicate before rewriting that history.

When Not to Amend

If the commit is old, already broadly shared, or the missing file deserves a separate history entry, a new commit may be better than amending.

git add path/to/file
git commit -m "Add missing file"

The technical ability to amend does not mean it is always the best collaborative choice.

Amending More Than Files

git commit --amend is also useful when you need to:

• fix the commit message
• add or remove staged changes
• correct author or metadata in some workflows

But the core rule stays the same: you are replacing the last commit with a new one.

Common Pitfalls

The most common mistake is forgetting that amending changes the commit hash.

Another mistake is force-pushing amended history without checking whether the branch is shared.

A third issue is using amend for changes that belong in a separate commit, which can make history less clear rather than more clear.

Finally, if you amend after staging unrelated changes accidentally, the new commit will include all staged content, not just the one file you intended.

Summary

• Stage the missing file with git add.
• Use git commit --amend or git commit --amend --no-edit to replace the last commit.
• Amending creates a new commit hash because it rewrites the commit.
• If the old commit was pushed, updating the remote usually requires git push --force-with-lease.
• Be cautious when the branch is shared with other developers.
• If history should remain explicit, a new commit may be better than amending.