Complete Guide: Abort Git Merge Conflict & Keep Remote

To abort a Git merge conflict and discard your local changes, use git merge --abort to cancel the merge operation, then git checkout --theirs some_file.txt to keep only the remote version of the conflicted file, or use git reset --hard origin/<branch> to completely reset your local branch to match the remote state.

Contents

• Aborting the Merge Process
• Discarding Local Changes and Keeping Remote Version
• Handling Individual Files
• Resetting to Remote State
• Preventing Future Conflicts

Aborting the Merge Process

When you encounter a merge conflict after running git pull, Git places your repository in a conflicted state. The first step is to abort the ongoing merge operation. According to the official Git documentation, you can use:

git merge --abort

This command:

• Reverses all changes made by the merge
• Resets the index and working tree to the state before the merge
• Cleans up any temporary files created during the merge attempt

Note: The git merge --abort command is the cleanest way to exit a merge conflict state. It ensures your repository returns to a clean, pre-merge state without losing any work.

As Atlassian’s Git Tutorial explains, when you see the message “You have unmerged paths. (fix conflicts and run ‘git commit’) (use ‘git merge --abort’ to abort the merge)”, this confirms you’re in a state where git merge --abort is the appropriate solution.

Discarding Local Changes and Keeping Remote Version

After aborting the merge, you need to ensure your local changes are discarded and you keep only the remote version. There are several approaches depending on your needs:

Method 1: Using --theirs for All Files

git merge --abort
git checkout --theirs .
git add -u
git commit -m "Merge remote changes"

This approach:

1. Aborts the merge
2. Uses --theirs to keep the remote version of all files
3. Marks all files as resolved
4. Commits the merge

As Stack Overflow contributors explain, git checkout --ours . keeps local versions while git checkout --theirs . keeps remote versions.

Method 2: Hard Reset to Remote

git reset --hard origin/<branch_name>

This command:

• Completely discards all local changes
• Resets your branch to exactly match the remote branch
• Is the most straightforward way to ensure only remote changes remain

Warning: git reset --hard is destructive and will permanently discard any uncommitted changes.

Stack Overflow confirms this is the solution when “your local branch diverged from the distant one.”

Handling Individual Files

When you want to keep remote changes for specific files while handling others differently, Git provides precise control:

For Specific Files

# Keep remote version of a specific file
git checkout origin/main -- path/to/file.txt

# Or use the theirs option
git checkout --theirs path/to/file.txt
git add path/to/file.txt

According to Stack Overflow, git checkout remote/branch -- path/to/myfile.txt works perfectly while resolving a merge conflict.

Using Merge Strategies

You can also specify merge strategies during the initial pull:

git pull -X theirs origin main

The -X theirs option tells Git to automatically resolve conflicts by preferring the remote version. As one Quora answer explains, “Use the ‘-X theirs’ option to git merge or git cherry-pick to specify it. This will cause it to resolve conflicts using…”

Resetting to Remote State

The most comprehensive approach when you want to discard all local changes and match the remote exactly is:

# Fetch the latest changes from remote
git fetch origin

# Reset your local branch to match the remote
git reset --hard origin/main

# Update your local branch reference
git pull origin main

This three-step process:

1. Ensures you have the latest remote state
2. Hard resets your branch to match exactly
3. Pulls to update everything

The Phoenixnap guide mentions using git stash to temporarily save changes, but when you want to completely discard local work, git reset --hard is more appropriate.

Preventing Future Conflicts

While the above solutions solve immediate problems, you can prevent similar conflicts in the future:

Better Pull Strategy

# Instead of git pull, use:
git fetch origin
git rebase origin/main

As one Stack Overflow answer suggests, “I never use git pull any more. Since in a fight between my latest code and the origin, the origin should always win, I always git fetch and git rebase origin. This actually makes my merges and conflicts few and far between.”

Configure Merge Driver

You can configure Git to automatically handle certain types of conflicts by preferring remote changes:

git config merge.ours.driver true
git config merge.theirs.driver true

However, this approach requires careful configuration and may not be suitable for all projects.

Sources

1. Git - git-merge Documentation - Using git merge --abort
2. How to Resolve Merge Conflicts in Git | Atlassian Git Tutorial
3. Stack Overflow - I ran into a merge conflict. How do I abort the merge?
4. Stack Overflow - How can I discard remote changes and mark a file as “resolved”?
5. Stack Overflow - How to keep the local file or the remote file during merge using Git
6. Phoenixnap - How To Resolve Merge Conflicts in Git
7. Stack Overflow - How to discard local changes and pull latest from GitHub
8. Quora - How can I discard merge conflicts during a merge using Git

Conclusion

Handling merge conflicts by discarding local changes and keeping remote versions is straightforward with the right Git commands. The key takeaways are:

1. Always start with git merge --abort to cleanly exit the conflicted merge state
2. Use git checkout --theirs for files where you want remote changes, or git checkout --ours for local changes
3. Consider git reset --hard origin/<branch> when you want to completely sync with remote
4. For specific files, use git checkout origin/branch -- path/to/file
5. Prevent future conflicts by using git fetch and git rebase instead of git pull

Remember that these operations are destructive - always ensure you’ve saved any important work before discarding changes. When in doubt, create a backup branch before performing destructive operations.