Move Uncommitted Changes to a New Branch in Git Without Losing Work

You are working on the main branch and suddenly realize your changes belong somewhere else. Maybe you started a new feature without creating a branch first. Maybe you were fixing a bug and do not want to mix it with other work. This happens to almost every developer.

The good news is that Git makes it easy to move uncommitted changes to a new branch. You do not need to copy files manually, delete code, or start again. If you follow the right steps, your work moves with you safely.

This guide shows you the simple method for unstaged and staged changes, the stash method for more complex cases, and how to avoid losing work in the process.

Quick Answer

To move uncommitted changes to a new branch, run git switch -c new-branch-name while your changes are still in the working folder. Git carries both staged and unstaged changes to the new branch automatically. Then run git add . and git commit -m "Your message" to save them on that new branch.

Why Move Changes to a New Branch?

Branches keep work separate and safe. The main branch should usually stay stable and ready to use. When you work directly on main, you risk mixing unfinished ideas with working code.

Moving changes to a new branch gives you freedom. You can experiment, pause, or ask for a review without affecting main. If the idea fails, you can delete the branch and main remains clean. If it succeeds, you can merge it back in an organized way.

Before You Start: Check Your Current Status

Before creating a branch, always check where you are and what has changed. This takes ten seconds and prevents most mistakes.

1. Run git status to see your current branch and a list of modified, staged, and untracked files.
2. Run git branch to confirm the branch you are on. The current branch is marked with a star.
3. Look carefully at untracked files. New files that Git has never tracked need special attention, especially if they are not meant to be committed.

If git status says your working tree is clean, you have no uncommitted changes to move. You can simply create a new branch and start working there.

For basics, see our complete GitHub beginner guide for branches and commits.

Method 1: Create a New Branch With git switch

This is the easiest and most recommended method for modern Git. It works for both staged and unstaged changes, as long as those changes do not conflict with the branch you are leaving behind in a way Git cannot handle. In a normal case where you create a brand new branch from your current commit, there is no conflict at all.

1. Make sure you have not committed the changes yet. Run git status to confirm they are still listed as modified or staged.
2. Create and switch to the new branch with git switch -c feature-login-page. Replace the name with a clear name for your work.
3. Run git status again. You should see the same changes, but now the top line says you are on the new branch.
4. Stage your changes with git add . or add specific files with git add filename.
5. Commit them with git commit -m "Add login page draft" using a message that explains the work.
6. Optionally, push the branch with git push -u origin feature-login-page if you want a backup on GitHub.

That is all. Your changes never left your folder. Git simply moved the branch pointer so your next commit belongs to the new branch instead of main.

Using the Older git checkout Command

Older tutorials use git checkout -b new-branch-name instead of git switch -c. Both commands do the same job for creating a branch. The switch command is newer and clearer because it is made only for moving between branches.

If your Git version is very old and switch does not work, use the checkout version without worry. The official Git switch command documentation explains the difference and why switch was introduced as a safer, more focused command.

Method 2: Use git stash to Move Changes

Sometimes the simple method is not enough. For example, you may want to move changes to a branch that already exists, or you may need to switch branches first before deciding where the work belongs. In those cases, stash is the right tool.

Stash temporarily shelves your changes and gives you a clean working folder. Then you can switch branches and bring the changes back.

1. Run git stash push -m "Work in progress on homepage" to save both staged and unstaged tracked changes with a helpful message.
2. If you also have new untracked files you want to stash, add the -u flag: git stash push -u -m "Include new files".
3. Create or switch to the target branch with git switch -c new-branch or git switch existing-branch.
4. Bring your changes back with git stash pop. This applies the stash and removes it from the stash list if it applies cleanly.
5. Check git status, then add and commit your changes as normal.

The official Git stash documentation covers advanced options, such as stashing only part of your work or keeping staged changes separate.

Moving Changes to an Existing Branch

Moving to a new branch is easy because the new branch starts from exactly where you are now. Moving to an existing branch needs more care, because that branch may have different commits.

The safest approach is the stash method described above. Stash your work, switch to the existing branch, then pop the stash. If the same lines were changed in both places, Git will show a conflict. That is normal. Open the files, choose the correct version, remove the conflict markers, and commit the result.

What Happens to Staged and Untracked Files?

Many beginners worry about the difference between staged and unstaged changes. When you create a new branch with git switch -c, both types move with you. Staged files stay staged, and unstaged files stay unstaged. Nothing is committed until you run the commit command yourself.

Untracked files also stay in your folder when you switch branches, because Git does not manage them yet. That can be helpful, but also risky. A new file you created for one feature will still be visible when you switch to another branch. Always check git status after switching so you do not commit a file to the wrong branch by accident.

If you use stash without -u, untracked files are not stashed. They will stay in place. Remember this difference if your work includes brand new files.

Common Mistakes to Avoid

• Committing before you switch: If you already committed to main, git switch -c will not move that commit. You will need a different fix, such as cherry-picking or resetting, which is more complex.
• Forgetting to check git status: Switching without knowing what is changed can lead to surprises, especially with untracked files.
• Using a vague branch name: Names like test or new become confusing after a week. Use names like feature-search-bar or fix-header-bug.
• Stashing and forgetting: A stash is temporary storage, not a backup. Pop it, commit it, or push it soon after you create it.
• Adding everything without reviewing: Running git add . without checking can include passwords, large files, or local settings. Review status first.
• Panicking during a conflict: A conflict after stash pop does not mean your work is lost. Your stash is still saved until you drop it, so take your time fixing the files.

Conclusion

Moving uncommitted changes to a new branch is one of the most useful Git skills you can learn. In most cases, a single command, git switch -c branch-name, does the whole job and carries your staged and unstaged work with you.

When you need to move work to an existing branch or tidy up first, stash gives you a safe second option. The key habit is simple: check git status before and after every switch. With that habit, you will never need to copy files by hand or fear losing work just because you started on the wrong branch.

Frequently Asked Questions

Will git switch -c lose my uncommitted changes?

No. When you create a new branch from your current position, Git keeps all staged and unstaged changes in your working folder. They simply belong to the new branch when you commit them. Always confirm with git status after switching.

What is the difference between git switch and git checkout for branches?

Both can create and move to a new branch. git switch -c is the modern, clearer command made only for branches. git checkout -b is the older command that also handles files, which is why many guides now prefer switch for beginners.

How do I move changes to a branch that already exists?

Use stash. Run git stash push -m "message", switch to the existing branch, then run git stash pop. This applies your changes on that branch so you can review and commit them there.

Do untracked files move to the new branch?

Untracked files stay in your folder when you switch branches, so they appear on the new branch as well. With stash, they only move if you add the -u flag. Always check status so you do not commit them to the wrong place.

What if I already committed my changes to main by mistake?

Create a new branch at that commit with git switch -c new-branch, then go back to main and remove the commit there with a careful reset if it has not been pushed. If it was already pushed and shared, talk to your team before rewriting history.