What is the difference between git merge and git rebase?

Merge joins two branches with a merge commit, preserving the exact history of both. Rebase replays your commits on top of another branch, producing a linear history but rewriting commit hashes. Use merge to integrate shared branches and rebase to tidy a local branch before sharing — never rebase commits others have already pulled.

How do I undo a commit without losing the change?

Use git reset --soft HEAD~1 to move the branch back one commit while keeping the change staged, or git revert to create a new commit that cancels an earlier one. Revert is safe on shared branches because it adds history rather than rewriting it; reset --hard discards work and should be used carefully.

What is the difference between git switch and git checkout?

git switch is a newer, focused command for changing branches (with -c to create one), while git checkout is older and overloaded — it switches branches and also restores files. For clarity, use git switch for branches and git restore for files; checkout still works for both.

Why use --force-with-lease instead of --force?

A plain --force overwrites the remote branch unconditionally, which can erase a teammate's commits you have not seen. --force-with-lease only pushes if the remote is still where you last saw it, refusing the push if someone else pushed in between. It is the safe way to update a branch after a rebase.

How do I recover a commit I think I lost?

Run git reflog, which records every position HEAD has held, including commits orphaned by reset or rebase. Find the SHA in the log, then git checkout or git branch from it to bring the commit back. Reflog entries are kept for weeks, so most accidental losses are recoverable.

Git Command Reference

Email me this result

Get this tool's output sent to your inbox, plus one useful tool a week. No spam, unsubscribe any time.

The git commands you actually use, organised

Git has hundreds of commands, but day-to-day work runs on a couple dozen. This reference groups the essentials by area — setup, staging, committing, branching, integrating, remotes and undo — with the common flags and a one-line description for each, so you can find the right command and its key options fast.

How it works

Git tracks three places: the working tree (your files), the index/staging area (what the next commit will contain) and the commit history. Most commands move changes between these:

git add -p              # stage selected hunks into the index
git commit -m "message" # record the index as a commit
git switch -c feature   # create and move onto a new branch
git rebase main         # replay feature commits onto the latest main
git push -u origin feature --force-with-lease

Remote commands (fetch, pull, push) sync that history with a server, and undo commands (reset, revert, restore, reflog) walk it back when something goes wrong.

Tips and notes

Stage precisely with git add -p so each commit is a coherent, reviewable change.
Prefer git revert on shared branches; reserve git reset --hard for local cleanup you are sure about.
Use git push --force-with-lease, never bare --force, after rebasing.
Keep git reflog in mind — it is your safety net for recovering commits that a reset or rebase appeared to delete.