Branches

A branch is a movable named pointer to a commit. It lets you develop a feature in isolation from main and merge the result back when it is ready, without your half-finished work ever touching the shared line of history. Because the pointer is the entire branch, creating one is nearly instant.

If branching feels heavyweight to you, that intuition comes from older systems where a branch was a directory copy on a server. In Git it is a 41-byte file. The cost of having ten branches open is ten small files; the cost of merging them later is the only thing worth thinking about.

What a Branch Actually Is

A branch is a file under .git/refs/heads/ containing one commit hash. That is the whole data structure. HEAD is a second pointer that names which branch you are currently on — usually it holds ref: refs/heads/main rather than a hash directly. When you commit, Git writes the new commit and then advances the current branch's hash to point at it; HEAD follows along because it points at the branch, not the commit.

This is why "switching branches" changes the files in your working tree but copies nothing: Git reads the snapshot the target branch points at and lays it down. The branch did not store those files — the commit it points to did.

Creating and Switching

Use git switch -c <name> to create a branch and move onto it in one step, and bare git switch <name> to move to an existing one. The older git checkout -b <name> does the same thing, but checkout is overloaded — it also discards file changes — and that overload is a frequent source of accidental data loss. New code should prefer switch for branches and restore for files, which split those two unrelated jobs apart.

A new branch starts at whatever commit HEAD is on when you create it. Branch from a stale local main and your feature starts behind the remote before you have written a line.

Tracking and Remote Branches

A local branch and its remote-tracking counterpart are different refs. main is your local branch; origin/main is a read-only local snapshot of where the remote's main was at your last fetch. Setting upstream tracking with git push -u origin <branch> links the two so a bare git push and git pull know where to go. Deleting a local branch does nothing to the remote — that takes git push origin --delete <branch>.

Listing and Deleting

git branch lists local branches with the current one marked. git branch -d <name> deletes a branch but refuses if its commits are not merged anywhere, which is the safety you want; git branch -D forces the delete regardless. The lowercase form is the one to reach for by default — the uppercase form throws away commits that only git reflog can recover.

Branching Strategies

Short-lived feature branches that live hours to a few days are the low-conflict path: they diverge from main for a small window, so the merge back is small. Trunk-based development pushes this further, integrating to main behind feature flags many times a day. The opposite — a branch that lives for weeks while main moves on — turns the eventual merge into a conflict-heavy ordeal that frequent integration would have avoided entirely.