Creating and Switching Branches

Analogy categoryAnalogies

Creating and switching branches are two of the most frequent operations in a Git workflow, performed every time you start a new feature, fix, or experiment. Historically both actions were handled by the overloaded git checkout command, which could switch branches, restore files, and create branches all with different flag combinations — a frequent source of confusion for newcomers. Git 2.23 introduced git switch and git restore specifically to split those responsibilities into clearer, purpose-built commands, though git checkout remains fully supported and widely used in existing scripts and muscle memory.

🏏

Cricket analogy: Creating and switching to a new net-practice pitch is one of the most frequent things a team does before every session; historically one all-purpose 'nets' request handled setting up, moving between pitches, and repairing turf, but modern academies now split those into dedicated ground staff roles for clarity.

Creating a branch

git branch <name> creates a new branch pointer at the current HEAD commit without switching to it — useful when you want to prepare a branch for someone else, or set one up before you're ready to start working on it. Far more commonly, developers create and switch in a single step using git switch -c <name> (or the older equivalent git checkout -b <name>), which both creates the pointer and updates HEAD and the working directory to match it in one command.

🏏

Cricket analogy: Naming a reserve player for a future match without actually fielding them yet is like git branch — the slot exists on the team sheet, ready when needed; naming and immediately sending them onto the field in one move is like git switch -c, prepping and starting in a single step.

Switching between branches

git switch <name> moves HEAD to point at an existing branch and updates the working directory and staging area to match that branch's latest commit. Git will refuse to switch if doing so would silently overwrite uncommitted changes that conflict with the target branch's files, protecting you from losing work — in that situation you typically need to commit, stash, or discard the conflicting changes first. Switching to a specific commit hash or tag rather than a branch name puts you in detached HEAD state, which is fine for inspection but requires creating a branch (git switch -c <name>) if you want to keep any new commits made there.

🏏

Cricket analogy: Switching your focus to a different match on TV won't let you overwrite unsaved notes about the current game — you'd be warned to finish or discard them first; watching an archived highlights reel (like a tag) is fine, but new notes there vanish unless you start a new notebook.

bash

# Create a branch at the current commit without switching to it
$ git branch feature/rate-limiting

# Create AND switch to a new branch in one step (modern syntax)
$ git switch -c feature/rate-limiting
Switched to a new branch 'feature/rate-limiting'

# Equivalent using the older checkout syntax
$ git checkout -b feature/rate-limiting

# Switch back to an existing branch
$ git switch main

# Create a branch based on a specific remote branch or tag
$ git switch -c hotfix/v2.3.1 v2.3.0

# List local branches, with the current one starred
$ git branch
  main
* feature/rate-limiting

# Delete a branch that has already been merged
$ git branch -d feature/rate-limiting

git switch -c <name> optionally accepts a starting point, e.g. git switch -c hotfix/urgent origin/main, letting you branch off any commit, tag, or remote-tracking branch instead of always branching from your current HEAD.

git checkout <path> (no branch name, just a file path) discards uncommitted changes to that file with no confirmation — this ambiguity between file-restoring and branch-switching behavior is exactly why git switch and git restore were introduced as safer, more explicit alternatives.

git branch <name> creates a branch pointer without switching to it; git switch -c <name> creates and switches in one step.
git switch <name> moves HEAD and updates the working directory to match an existing branch's tip commit.
Git blocks a switch that would overwrite uncommitted conflicting changes, prompting you to commit, stash, or discard first.
Checking out a specific commit or tag (not a branch) results in detached HEAD state.
git switch and git restore were introduced in Git 2.23 to split the overloaded responsibilities of git checkout.
git branch -d deletes a merged branch pointer safely; unmerged branches require the force flag -D.

Practice what you learned

1. Which command both creates a new branch and switches to it in a single step?

2. What happens when you check out a specific commit hash instead of a branch name?

3. Why were `git switch` and `git restore` introduced in Git 2.23?

4. What does `git branch -d feature-x` do if feature-x has unmerged commits?

5. How can you create a new branch starting from a specific tag rather than your current HEAD?

Was this page helpful?

What Are Branches?

Merging Branches

Related Study Notes in Software Engineering

Browse all study notes

Software Engineering

Microservices Study Notes

Software Architecture · 30 topics

Software Engineering

Testing & TDD Study Notes

Software Testing · 30 topics

Software Engineering

Design Patterns Study Notes

Software Design · 30 topics

Software Engineering

Software Engineering Study Notes

Python · 40 topics

Software Engineering

System Design Study Notes

Architecture · 40 topics

Topics covered

#Bash#GitVersionControlStudyNotes#SoftwareEngineering#CreatingAndSwitchingBranches#Creating#Switching#Branches#Branch#Git#StudyNotes#SkillVeris

Creating and Switching Branches