Git Cheat Sheet

git config --global user.name "Your Name"

# Set default author name.

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

# Set default author email.

git config --global core.editor "code --wait"

# Choose editor for commit messages and interactive rebase.

git config --global init.defaultBranch main

# Use main for new repositories.

git config --global pull.rebase true

# Avoid merge commits on pull.

git config --global rerere.enabled true

# Reuse recorded resolution for repeated conflicts.

git config --global alias.st status

# Add a short alias.

git config --global --add safe.directory /path/to/repo

# Allow Git to operate in a repository path marked safe.

git config --list --show-origin

# Show active configuration and where each value came from.

git help config

# View the Git config manual.

git init

# Create a new repository in the current directory.

git init --bare repo.git

# Create a repository without a working tree for server or shared use.

git clone https://github.com/owner/repo.git

# Clone a remote repository.

git clone --branch main --single-branch https://github.com/owner/repo.git

# Clone only one branch history.

git clone --depth 1 https://github.com/owner/repo.git

# Clone limited history for faster checkout.

git clone --filter=blob:none https://github.com/owner/repo.git

# Reduce object download size for large repos.

git rev-parse --show-toplevel

# Print the top-level working tree directory.

git archive --format=tar HEAD > repo.tar

# Create an archive from a tree-ish.

git archive --format=zip --prefix=repo/ HEAD > repo.zip

# Bundle repository files without the .git directory.

git status --short

# Compact status listing.

git status -sb

# Short status plus branch tracking summary.

git add path/to/file

# Stage a specific file.

git add -A

# Stage modified, deleted, and untracked files.

git add -p

# Select hunks to stage.

git restore path/to/file

# Restore file contents from HEAD or index.

git restore --staged path/to/file

# Remove a file from the index without losing edits.

git rm path/to/file

# Delete file and stage the removal.

git rm --cached path/to/file

# Keep the file locally but remove it from version control.

git mv old-name new-name

# Move or rename and stage the change.

git commit -m "Describe your change"

# Create a commit with a message.

git commit -am "Commit message"

# Commit tracked file modifications without separate add.

git commit --amend --no-edit

# Add staged changes into the previous commit.

git commit --fixup=<commit_sha>

# Prepare a fixup for autosquash rebase.

git commit --allow-empty -m "Trigger pipeline"

# Record an empty commit, often for automation.

git branch -a

# Show local and remote-tracking branches.

git branch -vv

# Include tracking and latest commit info.

git branch feature/my-change

# Create a branch at current HEAD.

git switch -c feature/my-change

# Create and switch in one step.

git switch main

# Switch to an existing branch.

git checkout <commit_sha>

# Inspect an older commit in detached HEAD state.

git branch -m new-branch-name

# Rename current branch.

git branch -d feature/my-change

# Delete a merged local branch.

git branch -D feature/my-change

# Delete local branch regardless of merge state.

git merge-base main feature/my-change

# Find common ancestor for two refs.

git remote -v

# Show remote names and URLs.

git remote add origin https://github.com/owner/repo.git

# Add a remote repository.

git remote set-url origin git@github.com:owner/repo.git

# Update fetch and push destination.

git fetch origin

# Download remote refs and objects.

git fetch --all --prune

# Refresh all remotes and remove stale remote-tracking branches.

git pull --rebase

# Fetch and replay local commits on top of upstream.

git push -u origin feature/my-change

# Push a new branch and configure tracking.

git push --force-with-lease

# Safer force push that refuses if remote moved unexpectedly.

git branch --set-upstream-to=origin/main main

# Link local branch to a remote-tracking branch.

git remote prune origin

# Delete stale remote-tracking refs.

git ls-remote --heads origin

# Inspect refs advertised by a remote.

git merge --no-ff feature/my-change

# Preserve branch history with an explicit merge commit.

git merge --squash feature/my-change

# Stage combined branch changes without creating a merge commit.

git merge --abort

# Return to pre-merge state after conflicts.

git rebase main

# Replay local commits on top of main.

git rebase -i HEAD~10

# Reorder, squash, reword, or drop commits.

git rebase -i --autosquash main

# Automatically place fixup/squash commits.

git rebase --continue

# Resume after resolving conflicts.

git rebase --abort

# Stop rebasing and restore branch state.

git cherry-pick <commit_sha>

# Apply one commit onto the current branch.

git cherry-pick A^..B

# Apply a contiguous commit range.

git cherry -v origin/main

# Show commits not yet upstream.

git rerere status

# Inspect remembered conflict resolutions.

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

# Compact visual history.

git log -- path/to/file

# Show commits touching a file.

git log --stat

# Show changed files with commit history.

git show <commit_sha>

# Display metadata, diff, and patch.

git diff

# Compare working tree to index.

git diff --staged

# Compare index to HEAD.

git diff main..feature/my-change

# Compare two refs.

git blame path/to/file

# See who last changed each line.

git grep "search text"

# Search in tracked content.

git shortlog -sn

# Count commits grouped by author.

git describe --tags

# Generate human-readable version identifiers.

git stash push -m "WIP"

# Save tracked changes.

git stash push -u -m "WIP with untracked"

# Save tracked and untracked files.

git stash list

# Inspect stash stack.

git stash show -p stash@{0}

# Inspect stash content as a patch.

git stash apply stash@{0}

# Restore stash without dropping it.

git stash pop

# Apply latest stash and remove it.

git stash drop stash@{0}

# Delete a stash entry.

git stash branch fixup stash@{0}

# Create branch, apply stash, and drop it on success.

git clean -nd

# See what untracked files would be removed.

git clean -fd

# Delete untracked files and directories.

git clean -fdX

# Clean build artifacts and ignored files.

git tag

# Show local tags.

git tag -a v1.2.0 -m "Release v1.2.0"

# Create a release tag with metadata.

git tag -s v1.2.0 -m "Signed release v1.2.0"

# Sign a release tag with GPG.

git show v1.2.0

# Inspect tag target and metadata.

git push origin v1.2.0

# Publish a tag.

git push origin --tags

# Publish all local tags.

git tag -d v1.2.0

# Remove a local tag.

git push origin :refs/tags/v1.2.0

# Remove a tag from the remote.

git reset --soft HEAD~1

# Move HEAD back and keep changes staged.

git reset --mixed HEAD~1

# Move HEAD back and unstage changes.

git reset --hard HEAD~1

# Discard commits and working tree changes.

git reset HEAD path/to/file

# Unstage a file using reset syntax.

git revert <commit_sha>

# Create a commit that undoes an earlier commit.

git revert --no-commit A^..B

# Stage reverse patches for a range and commit later.

git reflog

# See where refs and HEAD pointed previously.

git reset --hard HEAD@{1}

# Restore earlier branch state via reflog.

git fsck --lost-found

# Locate dangling commits and blobs after mistakes.

git checkout --orphan gh-pages

# Start a history with no parent commit.

git worktree list

# See linked working trees for the repo.

git worktree add ../repo-feature feature/my-change

# Create another working tree for a branch.

git worktree add -b fix/login ../repo-fix main

# Create new branch and worktree together.

git worktree remove ../repo-feature

# Delete a linked worktree.

git submodule add https://github.com/org/lib.git vendor/lib

# Track another repo as a submodule.

git submodule update --init --recursive

# Populate nested submodule content.

git submodule status --recursive

# Inspect submodule commit pointers.

git sparse-checkout init --cone

# Prepare a sparse working tree.

git sparse-checkout set src docs

# Limit checkout to selected directories.

git sparse-checkout disable

# Re-expand working tree.

git log --author="Alice"

# Filter commits by author.

git log --grep="fix login"

# Find commits with matching messages.

git log --since="2026-01-01"

# Limit history by time.

git log -S "FeatureFlag" -- source/file.ts

# Find commits that changed occurrence count for a string.

git log -G "useFeature\(" -- "*.ts"

# Find commits whose patch matches a regex.

git rev-list --count HEAD

# Return commit count for a ref.

git name-rev --name-only <commit_sha>

# Describe a commit relative to branch/tag refs.

git range-diff origin/main...v1 origin/main...v2

# Review rewritten patch series.

git bundle create repo.bundle --all

# Create a self-contained bundle of refs and objects.

git bundle verify repo.bundle

# Check if a bundle can be imported.

git clone repo.bundle repo-from-bundle

# Clone from a local bundle file.

git bisect start

# Begin binary search for a bad commit.

git bisect bad

# Mark current commit as bad.

git bisect good v1.0.0

# Mark a known-good revision.

git bisect run ./test-script.sh

# Use script exit codes to drive bisect.

git bisect reset

# Return to original branch state.

git gc --aggressive

# Compact repository storage more aggressively.

git maintenance run

# Execute configured maintenance operations.

git clone --mirror git@github.com:owner/repo.git

# Create a mirror including refs suitable for replication.

git remote update

# Fetch updates for configured remotes.

git update-server-info

# Refresh metadata for dumb HTTP serving.

touch .git/git-daemon-export-ok

# Allow export via git-daemon when configured.

git symbolic-ref HEAD refs/heads/main

# Point HEAD to a named branch ref.