Git Delete Local and Remote Branch: The Complete Guide

Every developer has stared at a repo with 47 branches named 'fix', 'fix2', 'test-thing', 'adi-temp', and 'FINAL_PLEASE'. Branch hygiene is one of those disciplines that seems trivial until it isn't — until a junior dev checks out the wrong branch, or a merge pipeline fails because it can't determine the base branch from the noise.

I spent three years as the sole platform engineer for a fintech startup where we ran 8-week feature sprints with 12 developers all branching off main simultaneously. We had a hard rule: the moment a PR merged, the branch got deleted — both locally and remotely — by the developer who opened it. Not by a cleanup cron job. Not by a script. By the person who created it, immediately. That discipline kept our branch list under 20 entries at all times and made git log --oneline actually readable.

This guide covers everything that matters in production: safe vs force delete, cleaning up stale remote-tracking refs, the difference between the remote branch and your local tracking reference, and the one-liner that nukes all branches you've already merged into main.

git branch -d vs git branch -D: The Critical Difference

Git gives you two local branch delete commands and the difference between them has saved and destroyed data in equal measure.

git branch -d <branch> is the safe delete. Git checks whether the branch tip is reachable from HEAD or from the branch it's supposed to be tracking upstream. If you have commits on that branch that aren't merged anywhere, Git refuses with: error: The branch 'feature/payment-retry' is not fully merged. That error message is Git doing you a favour.

git branch -D <branch> is the force delete — equivalent to --delete --force. It doesn't check anything. It just removes the ref. The commits still exist in the object store and are reachable via git reflog for 30 days by default, but the branch pointer is gone. This is the command you reach for when you've squash-merged a PR (the branch tip isn't reachable via normal ancestry) or when you genuinely want to abandon experimental work.

The mental model that's kept me out of trouble: -d is for branches you've properly merged via a merge commit. -D is for branches you've squash-merged, rebased, or are deliberately abandoning. Never use -D unless you can answer 'why does Git think this isn't merged?' — because sometimes the correct answer is 'I made a mistake and I'm about to lose work.'

# Safe delete — refuses if branch has unmerged commits
git branch -d feature/payment-retry

# Force delete — no safety check (use after squash-merge or to abandon work)
git branch -D feature/payment-retry

# Check what's merged into main before deleting
git branch --merged main
# Output: branches whose tips ARE reachable from main (safe to -d)

git branch --no-merged main
# Output: branches with commits NOT yet in main (need -D or review first)

# Practical: delete all local branches already merged into main
# (excluding main itself)
git branch --merged main | grep -v '\* main' | grep -v main | xargs git branch -d

Deleting Remote Branches with git push

Deleting a remote branch and deleting your local tracking reference for it are two separate operations. Most developers conflate them and then wonder why git branch -r still shows a deleted branch.

git push origin --delete <branch> sends a delete request to the remote. The remote branch on GitHub/GitLab/Bitbucket is gone. Other developers who fetch will get a notice that the branch has been deleted. This is the right command for post-merge cleanup.

The older syntax git push origin :<branch> (note the colon with no local branch name before it) does the same thing — it pushes 'nothing' to the remote branch reference, which deletes it. You'll see this in older scripts and blog posts. It works, but --delete is clearer and should be preferred in anything you write today.

One thing that caught me out early on: after running git push origin --delete feature/payment-retry, running git branch -r on a colleague's machine might still show origin/feature/payment-retry. That's their local remote-tracking reference — a cached copy of what their Git client last saw on the remote. It doesn't update automatically. They need to run git fetch --prune or configure pruning globally.

# Delete the remote branch (what lives on GitHub/GitLab/Bitbucket)
git push origin --delete feature/payment-retry

# Older syntax — same effect, less readable
git push origin :feature/payment-retry

# After remote delete: clean up YOUR stale remote-tracking refs
git fetch --prune
# This removes any local refs to remote branches that no longer exist
# e.g. removes origin/feature/payment-retry from your local tracking list

# Do both in one step (delete remote + prune all stale refs)
git push origin --delete feature/payment-retry && git fetch --prune

# Configure auto-prune so you never have stale refs again
git config --global fetch.prune true
# Now every git fetch and git pull automatically prunes dead tracking refs

Delete Local and Remote Branch in One Workflow

In practice you almost always want to delete both the local and remote branch together. Here's the sequence I've drilled into every team I've worked with — it takes 10 seconds and leaves the repo clean.

One common confusion: you can't delete the branch you're currently on. Git will tell you error: Cannot delete branch 'feature/payment-retry' checked out at '/home/adi/payments-service'. Switch to main first, then delete.

Another gotcha: if you renamed a branch mid-development (git branch -m old-name new-name), the old remote branch name might still exist. Deleting the new-named branch locally does nothing to the old remote ref. You need to explicitly delete the old remote branch name too.

# Full cleanup workflow — run after a PR is merged

# Step 1: Switch away from the branch you want to delete
git checkout main
git pull origin main   # Get latest main before cleanup

# Step 2: Delete local branch
git branch -d feature/payment-retry
# Use -D if you squash-merged (the tip won't be reachable via ancestry)

# Step 3: Delete the remote branch
git push origin --delete feature/payment-retry

# Step 4: Prune stale remote-tracking refs on your machine
git fetch --prune

# --- ONE-LINER for the muscle-memory inclined ---
git checkout main && git pull && git branch -d feature/payment-retry && git push origin --delete feature/payment-retry

# --- NUCLEAR: delete all local branches merged into main ---
# Review the list first before running
git branch --merged main | grep -vE '^\*|^\s*main$|^\s*master$|^\s*develop$'
# If the list looks right, pipe to delete:
git branch --merged main | grep -vE '^\*|^\s*main$|^\s*master$|^\s*develop$' | xargs -r git branch -d

Recovering a Deleted Branch with git reflog

You deleted a branch and immediately knew it was a mistake. Here's the thing — Git almost certainly still has those commits. The branch ref is gone but the commit objects remain in the local object store for 30 days (controlled by gc.reflogExpire). git reflog is your time machine.

git reflog shows a log of every time HEAD moved — including checkouts, commits, merges, and resets. Each entry has a short hash. Find the commit that was your branch tip before you deleted it and create a new branch pointing there.

This only works if you haven't run git gc aggressively and the 30-day window hasn't passed. For remote branch recovery after git push --delete, you need someone else on the team who still has the branch locally, or a backup from your remote (GitHub keeps deleted branch commits accessible for a period but makes it hard to recover — better to ask a teammate first).

# You deleted feature/payment-retry by mistake. Recover it:

# Step 1: Find the commit that was the branch tip
git reflog
# Look for the last checkout of the deleted branch or the last commit on it
# Output:
# a3f9c2e HEAD@{0}: checkout: moving from feature/payment-retry to main
# 7b2d4f1 HEAD@{1}: commit: Add retry logic with exponential backoff
# 9c3e8a2 HEAD@{2}: commit: Add PaymentRetryService skeleton

# Step 2: Recreate the branch at the commit you want
git branch feature/payment-retry a3f9c2e
# Or use the reflog shorthand:
git branch feature/payment-retry HEAD@{1}

# Step 3: Verify you got the right commits
git log feature/payment-retry --oneline -5

# If the branch was deleted remotely and you still have it locally:
git push origin feature/payment-retry
# Recreates the remote branch from your local copy

Frequently Asked Questions