Git command finder

git reset --soft HEAD~1

The commit is gone and its changes go back to staged, ready to commit again. Use HEAD~2 to undo two commits.

If you already pushed, prefer git revert so you do not rewrite shared history.

git reset --hard HEAD~1

Removes the commit and every change in it from your working folder.

If you already pushed, use git revert HEAD instead.

git revert <commit-sha>
git push

Creates a new commit that reverses the old one. History stays intact, which is safe for shared branches.

git commit --amend -m "Better message"

Replaces the most recent commit with one that has the new message.

Already pushed? Run git push --force-with-lease, and only on a branch nobody else is using.

git add path/to/file
git commit --amend --no-edit

Folds the file into the last commit and keeps its message.

git restore --staged path/to/file

The file stays changed on disk; it just leaves the staging area. Use . to unstage everything.

git restore path/to/file

Puts the file back to how it was in the last commit.

git reset --soft HEAD~1
git stash
git switch right-branch
git stash pop
git commit -m "Message"

Takes the commit off this branch, carries the changes over and commits them where they belong.

git switch -c new-branch

Uncommitted changes come with you to the new branch automatically.

git switch -c feature/name

The modern form of git checkout -b feature/name.

git branch -m old-name new-name
git push origin -u new-name
git push origin --delete old-name

Renames it locally, pushes the new name and removes the old one from the remote.

git branch -d branch-name
git push origin --delete branch-name

Use -D instead of -d to delete a branch that is not merged yet.

git stash push -m "What I was doing"
git stash list
git stash pop

Saves your work, cleans the folder, and brings it back later with pop.

git diff
git diff --staged

The first shows unstaged changes, the second what is about to be committed.

git reflog
git branch recovered <commit-sha>

reflog lists everywhere HEAD has been, even after a reset. Pick the commit and put a branch on it.

git reset --soft HEAD~3
git commit -m "One clear message"

Combines the last three commits. For more control, use git rebase -i HEAD~3.

If they were pushed, you will need git push --force-with-lease.

git remote add upstream https://github.com/OWNER/REPO.git
git fetch upstream
git rebase upstream/main
git push --force-with-lease

Adds the original repo once, then replays your work on top of its latest main.

git pull --rebase
git config --global pull.rebase true

Replays your local commits on top of the remote. The second line makes it the default.

git merge --abort
git rebase --abort

Puts everything back to how it was before you started.

git switch target-branch
git cherry-pick <commit-sha>

Applies that single commit on top of the current branch.

git rm --cached path/to/file
echo "path/to/file" >> .gitignore
git commit -m "Stop tracking file"

Removes it from the repository, keeps your local copy, and ignores it from now on.

pip install git-filter-repo
git filter-repo --invert-paths --path path/to/secret-file
git push --force --all

First rotate the secret: anyone may already have it. Then remove it from every commit.

git remote set-url origin git@github.com:OWNER/REPO.git
git remote -v

Points origin somewhere new, for example from HTTPS to SSH.

git log --oneline --graph --decorate --all

One line per commit with branches drawn as a graph.

git blame -L 10,20 path/to/file

Shows the last commit and author for lines 10 to 20.

git bisect start
git bisect bad
git bisect good <last-good-sha>
git bisect reset

Git checks out commits halfway between good and bad; you mark each one until it finds the culprit.

git tag -a v1.2.0 -m "Release 1.2.0"
git push origin v1.2.0

An annotated tag with a message, pushed to the remote.

git reset --hard ORIG_HEAD

Goes back to where you were before the pull.

git clone --depth 1 --branch main https://github.com/OWNER/REPO.git

Much faster for big repositories when you do not need the history.

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

Drop --global to set them for this repository only.

git clean -n -d
git clean -f -d

The first line previews what would be deleted. The second deletes it.

git checkout --theirs path/to/file
git checkout --ours path/to/file
git add path/to/file

During a merge, theirs is the incoming branch and ours is yours. During a rebase the two are swapped. Add the file to mark it resolved.

git reset --soft HEAD@{1}

Returns to the commit as it was before the amend, keeping the new changes staged.