Introduction: Fixing “Your local changes would be overwritten by merge”
When we get the Git error on the pull: “Your local changes to the following files would be overwritten by merge”, it means that you have some uncommitted changes in the working directory. Git cannot perform the merge operation because those changes would be lost or overwritten during the merge process. This post will describe the situation and a good solution to resolve this error while keeping local changes.
So you have got the error that looks like this:
git pull origin master remote: Enumerating objects: 14, done. remote: Counting objects: 100% (14/14), done. remote: Compressing objects: 100% (6/6), done. remote: Total 14 (delta 8), reused 14 (delta 8), pack-reused 0 Unpacking objects: 100% (14/14), done. From github.com:user/repo * branch master -> FETCH_HEAD 953146e..9f38420 master -> origin/master error: Your local changes to the following files would be overwritten by merge: List of your local files ...
Next, we go through the steps to resolve this problem.
Why Git Blocks the Pull: Uncommitted Local Changes
The Git message “error: Your local changes to the following files would be overwritten by merge” indicates that you have some uncommitted changes in your working directory, and Git cannot perform the merge operation because those changes would be lost or overwritten during the merge process.
When you attempt to merge a branch into your current branch using the git merge command, Git must combine the changes from both branches. However, if you have uncommitted changes in your working directory that conflict with the changes from the branch you’re trying to merge, Git will prevent the merge to avoid losing your local changes.
Solutions: Preserve Local Changes During git pull
Do you want to keep your local work while pulling changes from the remote? There should not be any merge conflicts since you have worked on different files.
To resolve this issue, you have a few options:
- Stash your changes: If you want to keep your local changes but still perform the merge, you can use the git stash command to temporarily save your changes, allowing you to perform the merge with a clean working directory. After the merge, you can use git stash apply or git stash pop to apply your saved changes to your working directory.
- Commit your changes: If you’re satisfied with your local changes and want to include them in the merge, commit them using git commit. After committing, you can proceed with the merge.
- Discard your changes: If you don’t need your local changes and want to proceed with the merge without them, you can use git reset –hard HEAD to discard the changes in your working directory and perform the merge.
Before taking any action, it’s a good idea to review your changes using git status or git diff to understand your modifications and decide the best course of action based on your needs. Always be cautious when using commands like git reset –hard or git stash drop as they can result in data loss.
It all looks nice. However, one command can give you a good painless solution:
git pull --rebase --autostash
The command above is used to update your local branch with changes from the remote repository using a rebase strategy while automatically stashing your local changes before the rebase operation.
The result looks like this:
Created autostash: 9bd05c7 HEAD is now at 3ea660f minor formatting changes First, rewinding head to replay your work on top of it... Applying: minor formatting changes Applied autostash. (base) X$ git status On branch master Your branch is ahead of 'origin/master' by 1 commit. (use "git push" to publish your local commits) ...
Here’s what each part of the command does:
-
git pull: The git pull command fetches and integrates changes from a remote repository into your current branch. It is equivalent to running git fetch followed by git merge by default. However, when you use additional options like –rebase, it will use rebase instead of merge to integrate changes.
-
–rebase: This option tells Git to use the rebase strategy instead of the default merge strategy when integrating the remote changes into your local branch. Rebase moves your local changes on top of the remote changes, resulting in a linear history. It is often preferred for its cleaner commit history compared to merge.
-
–autostash: This option automatically stashes your local changes (if any) before starting the rebase process. Stashing allows you to save your work temporarily, making it possible to perform the rebase on a clean working directory. Once the rebase is completed, Git will automatically apply the stashed changes to your working directory.
The combined command git pull –rebase –autostash is handy when you want to pull and rebase your local branch on top of the latest changes from the remote repository, even if you have some uncommitted changes in your working directory. It streamlines the process by stashing your local changes, pulling the remote changes, and then applying your local changes back on top of the updated branch after the rebase is complete.
Remember that when using git pull –rebase, conflicts may arise during the rebase process if your local changes conflict with the changes from the remote branch. You will need to resolve these conflicts manually before completing the rebase.
Conclusion: git pull –rebase –autostash
We have solved the “Your local changes to the following files would be overwritten by merge” error with just one combined Git command, which keeps our local changes merged on top of pulled remote changes. git pull --rebase --autostash stashes uncommitted changes, rebases your branch onto the latest remote commits, then reapplies the stashed changes — preserving local work without creating a merge commit.
Now you know how to use git pull --rebase --autostash effectively.
Git Pull: Preserve Local Changes FAQ
What causes the error “Your local changes to the following files would be overwritten by merge”?
It means you have uncommitted changes in your working directory that conflict with the commits Git is trying to merge during a pull. Git aborts the merge to avoid silently overwriting your local work.
How do I pull from the remote without losing my uncommitted changes?
Run git pull --rebase --autostash. It automatically stashes your local changes, rebases your branch onto the remote commits, and reapplies the stashed changes afterwards.
What does git stash do before pulling?
git stash temporarily saves your uncommitted changes and restores a clean working directory so the merge can proceed. Recover the changes afterwards with git stash pop or git stash apply.
How do I discard local changes and pull anyway?
Run git reset --hard HEAD to discard all uncommitted changes, then pull. This is destructive and irreversibly removes your local modifications, so use it only when you do not need them.
Did you like this post? Please let me know if you have any comments or suggestions.
Git posts that might be interesting for youDisclaimer: I have used chatGPT and Midjourney while preparing this post, and this is why I have listed the chatGPT in my references section. However, most of the text is rewritten by me, as a human, and spell-checked with Grammarly.
Bibliography
Enjoyed this? Get more like it.
Weekly notes on AI tools, Python, and what I'm actually building — plus a free copy of Fantastic AI: The 2026 Toolkit.
