How to Move Uncommitted Changes to New Branch in Git

To move existing uncommitted changes to a new branch and reset your current branch in Git, you can use the git checkout -b <new-branch-name> command to create and switch to a new branch while preserving your uncommitted changes, then reset the original branch with git reset --hard HEAD to remove all uncommitted work from it. This approach safely transfers your work to a dedicated branch while cleaning up the original branch to its last committed state.

Contents

• The Basic Two-Step Method
• Alternative Approaches
• Safety Considerations
• Step-by-Step Example
• Troubleshooting Common Issues

The Basic Two-Step Method

The simplest and most direct method involves just two Git commands to achieve your goal:

Step 1: Create and Switch to New Branch

git checkout -b <new-branch-name>

This command creates a new branch with the specified name and immediately switches to it, while automatically bringing all your uncommitted changes along with you. According to the Atlassian Git documentation, this is the recommended approach when you want to preserve uncommitted work on a new branch.

Step 2: Reset the Original Branch

After switching to the new branch, you need to reset the original branch to remove the uncommitted changes:

git checkout <original-branch>
git reset --hard HEAD

The git reset --hard HEAD command completely discards all uncommitted changes, bringing the branch back to its last committed state. As Linuxbeast explains, this command resets the branch to its latest committed state, effectively cleaning it.

Alternative Approaches

Using Git Switch (Git 2.23+)

If you’re using Git version 2.23 or later, you can use the more modern git switch command:

git switch -c <new-branch-name>
git switch <original-branch>
git reset --hard HEAD

The -c flag creates a new branch and switches to it, similar to checkout -b.

Using Stash for Safety

For added safety, especially when dealing with complex changes:

git stash
git checkout <original-branch>
git reset --hard HEAD
git checkout -b <new-branch-name>
git stash pop

This approach temporarily stores your changes, resets the original branch safely, then applies the changes to your new branch.

Using Git Branch Force Reset

For more complex scenarios where you need to reset tracking information:

git checkout -b <new-branch-name>
git checkout <original-branch>
git reset --hard HEAD
# If needed: git branch -f <original-branch> origin/<original-branch>

Safety Considerations

Always Check Your Status

Before performing any reset operations, check your current state:

git status
git diff

This ensures you understand exactly what changes you’re about to move.

Backup Important Changes

If your changes are particularly valuable, consider creating a backup commit first:

git add .
git commit -m "Temporary backup before branch move"

Then proceed with the branch creation and reset process.

Avoid Hard Reset on Shared Branches

As the Stack Overflow community warns, be careful with git reset --hard on shared branches, as this rewrites history and can cause issues for other team members.

Step-by-Step Example

Let’s walk through a complete example:

1. Start with uncommitted changes on main branch:

   bash

   git status
   # On branch main
   # Changes not staged for commit:
   #   (use "git add <file>..." to update what will be committed)
   #   (use "git restore <file>..." to discard changes in working directory)
   #       modified:   src/component.js
   #       modified:   README.md
   

2. Create and switch to feature branch:

   bash

   git checkout -b feature-authentication
   # Switched to a new branch 'feature-authentication'
   

3. Verify changes are on the new branch:

   bash

   git status
   # On branch feature-authentication
   # Changes not staged for commit:
   #   (use "git add <file>..." to update what will be committed)
   #   (use "git restore <file>..." to discard changes in working directory)
   #       modified:   src/component.js
   #       modified:   README.md
   

4. Switch back to main and reset:

   bash

   git checkout main
   git reset --hard HEAD
   

5. Verify main is clean:

   bash

   git status
   # On branch main
   # nothing to commit, working tree clean
   

Troubleshooting Common Issues

“fatal: You have local changes to…”

If you encounter this error when trying to checkout another branch, it typically means the changes conflict with the target branch. The solution is to either commit your changes first or use the stash approach mentioned earlier.

Accidentally Reset the Wrong Branch

If you reset the wrong branch by mistake, you can often recover your changes:

git reflog  # Find the commit hash before the reset
git reset --hard <commit-hash>

Changes Not Appearing on New Branch

If your changes don’t appear on the new branch, check if they were staged:

git reset HEAD  # Unstage all changes
git checkout -b <new-branch>

Sources

1. Move Existing, Uncommitted Work to a New Branch in Git | Better Stack Community
2. Safety Moving Uncommitted Changes to A New Branch in Git | Linuxbeast
3. Move existing, uncommitted work to a new branch in Git - Stack Overflow
4. Resetting, Checking Out & Reverting | Atlassian Git Tutorial
5. How to Move Uncommitted Changes to a New Branch in Git - Sarathlal N
6. Moving Uncommitted Modifications to a New Git Branch

Conclusion

Moving uncommitted changes to a new branch and resetting the current branch is a straightforward Git workflow that can be accomplished with just a few commands. The basic two-step method using git checkout -b followed by git reset --hard is the most direct approach, while alternative methods like using stashes or the git switch command offer additional safety and flexibility depending on your specific needs.

Key takeaways:

• Always verify your changes before performing reset operations
• Consider using stashing for added safety, especially with complex changes
• Be cautious with git reset --hard on shared branches
• Git 2.23+ users can use the more modern git switch -c command

This workflow is particularly useful when you realize mid-development that your work belongs on a dedicated feature branch rather than your current working branch.