$devvkit resources --cheatsheet git-cheatsheet

Git Cheatsheet

[version-control]

Every Git command you need for daily development: from init to advanced history rewriting, with syntax and real use cases.147 commands · 10 sections

Git is the industry-standard version control system. This cheatsheet covers every command across the full Git workflow: creating and cloning repositories, staging and committing changes, branching and merging, collaborating with remotes, inspecting history, stashing work, and undoing mistakes.

Every command shows its real syntax followed by the use case: when and why you reach for it. Commands are grouped by workflow stage so you can find what you need quickly.

Setup & Config15

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

Use case: Set your Git username globally: required before your first commit.Example: git config --global user.name "Jane Doe"

$git config --global user.email "email"

Use case: Set the email attached to every commit. Match your GitHub/GitLab account.Example: git config --global user.email "jane@example.com"

$git config --global init.defaultBranch main

Use case: Use main as the default branch name for every new repository instead of master.Example: git config --global init.defaultBranch main

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

Use case: Set your editor for commit messages and interactive rebases: VS Code opens and waits for you to save.Example: git config --global core.editor "code --wait"

$git config --global core.autocrlf input

Use case: Prevent CRLF/LF line-ending noise on cross-platform teams (use input on macOS/Linux, true on Windows).Example: git config --global core.autocrlf input

$git config --global pull.rebase true

Use case: Rebase your local commits on top of pulled changes instead of creating merge commits.Example: git config --global pull.rebase true

$git config --global alias.co checkout

Use case: Create a shorthand alias: type git co instead of git checkout.Example: git config --global alias.co checkout

$git config --global alias.lg "log --oneline --graph --decorate --all"

Use case: Define a pretty one-line history graph you will actually use daily.Example: git config --global alias.lg "log --oneline --graph --decorate --all"

$git config --list

Use case: Show every resolved config value: system, global, and local: to debug weird Git behavior.Example: git config --list

$git config --global --unset user.email

Use case: Remove a config key when it is wrong or no longer needed.Example: git config --global --unset user.email

$git config core.sshCommand "ssh -i ~/.ssh/deploy_key"

Use case: Use a specific SSH key for one repository: essential when you manage multiple GitHub accounts.Example: git config core.sshCommand "ssh -i ~/.ssh/deploy_key"

$git config --global credential.helper store

Use case: Cache credentials in plain text so Git stops asking for your password on every push.Example: git config --global credential.helper store

$git config --global diff.tool vscode

Use case: Set a difftool so git difftool opens your editor for side-by-side diffs.Example: git config --global diff.tool vscode

$git config --global merge.tool vscode

Use case: Set a mergetool that opens your editor's merge view to resolve conflicts visually.Example: git config --global merge.tool vscode

$git config --global core.excludesfile ~/.gitignore_global

Use case: Point to a global gitignore for files you never want tracked in any repo (.DS_Store, Thumbs.db).Example: git config --global core.excludesfile ~/.gitignore_global

Repositories8

$git init

Use case: Create a new empty repository in the current directory.Example: git init

$git init --bare repo.git

Use case: Create a bare repository: no working tree: for a central server or remote you never edit directly.Example: git init --bare server.git

$git clone <url>

Use case: Copy an existing remote repository to your machine with full history.Example: git clone https://github.com/user/repo.git

$git clone --depth 1 <url>

Use case: Shallow clone: only the latest commit. Use for CI, deployment, or huge repos.Example: git clone --depth 1 https://github.com/user/repo.git

$git clone --branch <tag> <url>

Use case: Clone and check out a specific branch or tag immediately.Example: git clone --branch v2.0.0 https://github.com/user/repo.git

$git clone --recurse-submodules <url>

Use case: Clone a repo and initialize all its submodules in one step.Example: git clone --recurse-submodules https://github.com/user/repo.git

$git status

Use case: Show the working tree state: modified, staged, and untracked files. Run it constantly.Example: git status

$git status --short

Use case: Compact one-line-per-file status output: perfect for terminal muscle memory.Example: git status --short

Staging & Committing16

$git add <file>

Use case: Stage a file: mark it to be included in the next commit.Example: git add src/index.ts

$git add .

Use case: Stage every change in the current directory (including deletions).Example: git add .

$git add -p

Use case: Stage changes interactively hunk-by-hunk: keep unrelated edits out of a commit.Example: git add -p src/index.ts

$git add -u

Use case: Stage only modified and deleted tracked files: never new untracked files.Example: git add -u

$git commit -m "message"

Use case: Create a commit from staged changes with a message.Example: git commit -m "fix: handle empty payloads"

$git commit -am "message"

Use case: Stage all tracked changes and commit in one step (untracked files are not included).Example: git commit -am "refactor: extract client"

$git commit --amend

Use case: Rewrite the last commit's message, or fold new staged changes into it. Never amend pushed commits.Example: git commit --amend -m "feat: better message"

$git commit --amend --no-edit

Use case: Add forgotten changes to the last commit without touching its message.Example: git add . && git commit --amend --no-edit

$git commit --fixup=<commit>

Use case: Create a fixup commit that autosquashes into another commit during rebase: tidy PR history.Example: git commit --fixup=abc1234

$git commit --squash=<commit>

Use case: Create a squash commit to merge into another during rebase --autosquash.Example: git commit --squash=abc1234

$git diff

Use case: Show unstaged changes: what would change if you committed right now.Example: git diff

$git diff --staged

Use case: Show staged changes: exactly what the next commit will contain.Example: git diff --staged

$git diff <file>

Use case: Show changes to a single file only.Example: git diff src/index.ts

$git diff HEAD

Use case: Show all changes: staged and unstaged: against the last commit.Example: git diff HEAD

$git diff --stat

Use case: Summarize changes with per-file line counts instead of full diffs.Example: git diff --stat

$git diff main...feature

Use case: Compare your feature branch against the point it diverged from main: ignores main's newer commits.Example: git diff main...feature

Branching & Merging20

$git branch

Use case: List local branches; the * marks your current branch.Example: git branch

$git branch -a

Use case: List all branches including remote-tracking branches.Example: git branch -a

$git branch -vv

Use case: Show which remote each branch tracks and how far ahead/behind it is.Example: git branch -vv

$git branch <name>

Use case: Create a new branch at your current commit (does not switch to it).Example: git branch feature/auth

$git switch -c <name>

Use case: Create a branch and switch to it in one move: the modern replacement for checkout -b.Example: git switch -c feature/auth

$git switch <name>

Use case: Switch to an existing branch or remote-tracking branch.Example: git switch main

$git switch -

Use case: Switch back to the branch you were on before: like cd -.Example: git switch -

$git checkout <file>

Use case: Discard unstaged changes to a file, restoring it from the index.Example: git checkout src/index.ts

$git branch -d <name>

Use case: Delete a fully merged local branch. Use -D to force-delete unmerged work.Example: git branch -d feature/auth

$git merge <branch>

Use case: Merge another branch into your current branch, creating a merge commit.Example: git merge feature/auth

$git merge --no-ff <branch>

Use case: Force a merge commit even when a fast-forward is possible: keeps feature boundaries visible.Example: git merge --no-ff feature/auth

$git merge --abort

Use case: Abort a conflicted merge and restore the pre-merge state.Example: git merge --abort

$git rebase <branch>

Use case: Replay your commits on top of another branch for a linear history.Example: git rebase main

$git rebase -i HEAD~n

Use case: Interactive rebase: reword, reorder, squash, and drop commits in the last n.Example: git rebase -i HEAD~3

$git rebase -i --autosquash HEAD~n

Use case: Automatically fold fixup! and squash! commits into their targets during interactive rebase.Example: git rebase -i --autosquash HEAD~5

$git rebase --continue

Use case: Continue a rebase after resolving conflicts and staging the fixes.Example: git rebase --continue

$git rebase --abort

Use case: Cancel a rebase entirely and return to the pre-rebase state.Example: git rebase --abort

$git cherry-pick <commit>

Use case: Apply a single commit from another branch onto your current one: handy for hotfixes.Example: git cherry-pick abc1234

$git cherry-pick -n <commit>

Use case: Apply a commit without committing: stage several cherry-picks for one commit.Example: git cherry-pick -n abc1234

$git merge --squash <branch>

Use case: Merge a branch as a single squashed change staged for one commit.Example: git merge --squash feature/auth

Inspecting & Comparing20

$git log

Use case: Show commit history with full details.Example: git log

$git log --oneline

Use case: One line per commit: hash plus subject. The default way to read history.Example: git log --oneline

$git log --oneline --graph --all

Use case: Visual branch graph across every branch: see how history actually forked and merged.Example: git log --oneline --graph --all

$git log --oneline -n 10

Use case: Show only the last 10 commits.Example: git log --oneline -n 10

$git log --author="jane" --oneline

Use case: Filter history by author: count your contributions or audit a teammate.Example: git log --author="jane" --oneline

$git log --since="2 weeks ago" --oneline

Use case: Show commits since a date: your weekly review.Example: git log --since="2 weeks ago" --oneline

$git log --grep="fix:" --oneline

Use case: Search commit messages for a pattern: find every fix commit.Example: git log --grep="fix:" --oneline

$git log -p <file>

Use case: Show the full patch history of a single file: find when a line changed.Example: git log -p src/index.ts

$git log -S "string" --oneline

Use case: Pickaxe search: find commits that added or removed a specific string (the infamous "where did this line come from").Example: git log -S "apiKey" --oneline

$git log -G "regex" --oneline

Use case: Find commits whose diff matches a regex: more flexible than -S.Example: git log -G "TODO|FIXME" --oneline

$git blame <file>

Use case: Show who changed each line and in which commit: the code archaeology tool.Example: git blame src/index.ts

$git show <commit>

Use case: Show a commit: its metadata and full diff.Example: git show abc1234

$git show HEAD

Use case: Show the latest commit on your branch.Example: git show HEAD

$git show HEAD~1:path/to/file

Use case: Show a file's contents at a past commit without checking it out.Example: git show HEAD~1:src/index.ts

$git reflog

Use case: Show every HEAD movement: your safety net to recover "lost" commits after resets.Example: git reflog

$git diff HEAD~1 HEAD

Use case: Compare the last commit against its parent.Example: git diff HEAD~1 HEAD

$git shortlog -sn

Use case: Summarize commits per author, sorted: your contribution report.Example: git shortlog -sn

$git count-objects -vH

Use case: Check repository size and object counts: when your .git is bloating.Example: git count-objects -vH

$git rev-parse HEAD

Use case: Print the full hash of the current commit: useful in scripts and CI.Example: git rev-parse HEAD

$git describe --tags

Use case: Describe the nearest tag to HEAD, e.g. v2.0.0-3-gabc1234: auto version labels.Example: git describe --tags

Undoing Changes15

$git restore <file>

Use case: Discard unstaged changes in a file: restore it from the index.Example: git restore src/index.ts

$git restore --staged <file>

Use case: Unstage a file: keep changes in the working tree.Example: git restore --staged src/index.ts

$git restore --source=HEAD~1 <file>

Use case: Restore a file from a specific commit, discarding newer changes.Example: git restore --source=HEAD~1 src/index.ts

$git reset --soft HEAD~1

Use case: Undo the last commit but keep changes staged: fix a commit message or add more to it.Example: git reset --soft HEAD~1

$git reset HEAD~1

Use case: Undo the last commit and unstage changes (mixed reset: working tree keeps edits).Example: git reset HEAD~1

$git reset --hard HEAD~1

Use case: Undo the last commit AND discard its changes entirely. Dangerous: never on pushed history.Example: git reset --hard HEAD~1

$git reset --hard <commit>

Use case: Move the branch pointer and working tree to any commit: nuke everything after it.Example: git reset --hard abc1234

$git revert <commit>

Use case: Create a new commit that undoes another commit: the safe way to undo pushed history.Example: git revert abc1234

$git revert -n <commit>

Use case: Revert without committing: combine multiple reverts or adjust first.Example: git revert -n abc1234

$git clean -fd

Use case: Delete untracked files and directories: clean up build artifacts or stray files.Example: git clean -fd

$git clean -fdX

Use case: Delete only ignored files (build output, caches) while keeping untracked source.Example: git clean -fdX

$git update-ref -d HEAD

Use case: Delete the branch pointer entirely: start committing fresh in an empty repo.Example: git update-ref -d HEAD

$git bisect start && git bisect bad && git bisect good <commit>

Use case: Binary search history for the commit that introduced a bug.Example: git bisect start; git bisect bad; git bisect good v1.0.0

$git bisect run <script>

Use case: Automate bisecting: a script that exits 0 for good and nonzero for bad finds the culprit.Example: git bisect run npm test

$git bisect reset

Use case: Leave bisect mode and return to the original commit.Example: git bisect reset

Remote Collaboration21

$git remote -v

Use case: List remotes with fetch and push URLs.Example: git remote -v

$git remote add origin <url>

Use case: Add a remote: typically your GitHub/GitLab repo.Example: git remote add origin https://github.com/user/repo.git

$git remote rename <old> <new>

Use case: Rename a remote, updating all tracking references.Example: git remote rename origin upstream

$git remote set-url origin <url>

Use case: Change a remote URL: e.g. when switching from HTTPS to SSH or moving a repo.Example: git remote set-url origin git@github.com:user/repo.git

$git remote remove <name>

Use case: Delete a remote and its tracking branches.Example: git remote remove backup

$git fetch origin

Use case: Download remote commits and branches without merging them.Example: git fetch origin

$git fetch --prune origin

Use case: Fetch and delete local refs for branches deleted on the remote.Example: git fetch --prune origin

$git pull

Use case: Fetch and merge remote changes into your current branch.Example: git pull

$git pull --rebase

Use case: Fetch and rebase local commits onto the remote: cleaner linear history.Example: git pull --rebase

$git push

Use case: Push committed changes to the remote tracking branch.Example: git push

$git push -u origin <branch>

Use case: Push a new branch and set upstream tracking: after this, plain git push works.Example: git push -u origin feature/auth

$git push --force-with-lease

Use case: Force-push only if nobody else pushed since your last fetch: the safe force.Example: git push --force-with-lease

$git push origin --delete <branch>

Use case: Delete a branch on the remote.Example: git push origin --delete feature/auth

$git push --tags

Use case: Push all local tags to the remote: releases and version markers.Example: git push --tags

$git push --all origin

Use case: Push every local branch to origin at once: sync after a fresh clone.Example: git push --all origin

$git ls-remote origin

Use case: List refs on a remote without cloning: check if a tag or branch exists.Example: git ls-remote origin

$git submodule add <url> <path>

Use case: Pin an external repo inside your repo at a fixed commit.Example: git submodule add https://github.com/user/lib.git lib

$git submodule update --init --recursive

Use case: Initialize and fetch all nested submodules after cloning or switching branches.Example: git submodule update --init --recursive

$git worktree add ../hotfix main

Use case: Check out another branch in a separate directory: work on two branches without stashing.Example: git worktree add ../hotfix main

$git worktree list

Use case: List all linked worktrees.Example: git worktree list

$git request-pull origin main https://github.com/user/repo

Use case: Generate a summary of changes to email to a maintainer when submitting patches.Example: git request-pull origin main https://github.com/user/repo

Stashing12

$git stash

Use case: Save all uncommitted changes and clean the working tree: switch branches freely.Example: git stash

$git stash push -m "message"

Use case: Stash with a label so you can identify it later.Example: git stash push -m "wip: auth flow"

$git stash push <file>

Use case: Stash only specific files: keep unrelated work in place.Example: git stash push src/index.ts

$git stash --keep-index

Use case: Stash working changes but keep staged changes: commit part of your work first.Example: git stash --keep-index

$git stash list

Use case: List all stashes with their labels and branch.Example: git stash list

$git stash apply

Use case: Reapply the latest stash but keep it in the list: apply to multiple branches.Example: git stash apply

$git stash pop

Use case: Reapply the latest stash and drop it from the list: normal workflow.Example: git stash pop

$git stash show -p stash@{1}

Use case: Preview a specific stash's diff before applying it.Example: git stash show -p stash@{1}

$git stash drop stash@{0}

Use case: Delete a stash permanently.Example: git stash drop stash@{0}

$git stash clear

Use case: Delete every stash: clean up an untidy stash list.Example: git stash clear

$git stash branch <name>

Use case: Create a branch from a stash's base commit and pop the stash onto it.Example: git stash branch fix/typo

$git stash -u

Use case: Stash untracked files too: not just tracked modifications.Example: git stash -u

Tags & Releases10

$git tag

Use case: List all tags.Example: git tag

$git tag v1.0.0

Use case: Create a lightweight tag at the current commit.Example: git tag v1.0.0

$git tag -a v1.0.0 -m "Release v1.0.0"

Use case: Create an annotated tag with a message: recommended for releases.Example: git tag -a v1.0.0 -m "Release v1.0.0"

$git tag -a v1.0.0 <commit>

Use case: Tag a past commit: release a hotfix on an old version.Example: git tag -a v1.0.0 abc1234

$git tag -d v1.0.0

Use case: Delete a local tag.Example: git tag -d v1.0.0

$git push origin --delete v1.0.0

Use case: Delete a tag on the remote.Example: git push origin --delete v1.0.0

$git checkout v1.0.0

Use case: Detach HEAD at a tag: inspect a release's exact code.Example: git checkout v1.0.0

$git show v1.0.0

Use case: Show the tagged commit and its diff.Example: git show v1.0.0

$git log v1.0.0..v2.0.0 --oneline

Use case: List all commits between two releases: write your changelog.Example: git log v1.0.0..v2.0.0 --oneline

$git tag --contains <commit>

Use case: Find which releases contain a specific commit.Example: git tag --contains abc1234

Advanced History10

$git gc

Use case: Optimize the repository by compressing loose objects and pruning unreachable ones.Example: git gc

$git gc --aggressive --prune=now

Use case: Full housekeeping: do this when your .git folder is huge.Example: git gc --aggressive --prune=now

$git fsck --lost-found

Use case: Find dangling commits and objects: recover work after a botched reset.Example: git fsck --lost-found

$git filter-branch --force --index-filter "git rm --cached --ignore-unmatch .env" --prune-empty -- --all

Use case: Remove a file (like .env with secrets) from all of history: last resort, use filter-repo if available.Example: git filter-branch --force --index-filter "git rm --cached --ignore-unmatch .env" --prune-empty -- --all

$git replace <old> <new>

Use case: Temporarily substitute one commit for another: graft histories without rewriting.Example: git replace abc1234 def5678

$git archive --format=zip -o release.zip HEAD

Use case: Export the current commit as a zip without the .git folder.Example: git archive --format=zip -o release.zip HEAD

$git apply <patchfile>

Use case: Apply a diff patch file to the working tree.Example: git apply changes.patch

$git format-patch -1 HEAD

Use case: Generate a patch file for the last commit: email or share it without pushing.Example: git format-patch -1 HEAD

$git subtree add --prefix=lib <url> <branch>

Use case: Add a repository as a subtree: an alternative to submodules that inlines the code.Example: git subtree add --prefix=lib https://github.com/user/lib.git main

$git subtree pull --prefix=lib <url> <branch>

Use case: Pull upstream changes into a subtree.Example: git subtree pull --prefix=lib https://github.com/user/lib.git main

Git Cheatsheet

Every Git command you need for daily development: from init to advanced history rewriting, with syntax and real use cases.

Every command shows its real syntax followed by the use case: when and why you reach for it. Commands are grouped by workflow stage so you can find what you need quickly.

Setup & Config

git config --global user.name "Name": Set your Git username globally: required before your first commit.

Example: git config --global user.name "Jane Doe"

git config --global user.email "email": Set the email attached to every commit. Match your GitHub/GitLab account.

Example: git config --global user.email "jane@example.com"

git config --global init.defaultBranch main: Use main as the default branch name for every new repository instead of master.

Example: git config --global init.defaultBranch main

git config --global core.editor "code --wait": Set your editor for commit messages and interactive rebases: VS Code opens and waits for you to save.

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

git config --global core.autocrlf input: Prevent CRLF/LF line-ending noise on cross-platform teams (use input on macOS/Linux, true on Windows).

Example: git config --global core.autocrlf input

git config --global pull.rebase true: Rebase your local commits on top of pulled changes instead of creating merge commits.

Example: git config --global pull.rebase true

git config --global alias.co checkout: Create a shorthand alias: type git co instead of git checkout.

Example: git config --global alias.co checkout

git config --global alias.lg "log --oneline --graph --decorate --all": Define a pretty one-line history graph you will actually use daily.

Example: git config --global alias.lg "log --oneline --graph --decorate --all"

git config --list: Show every resolved config value: system, global, and local: to debug weird Git behavior.

Example: git config --list

git config --global --unset user.email: Remove a config key when it is wrong or no longer needed.

Example: git config --global --unset user.email

git config core.sshCommand "ssh -i ~/.ssh/deploy_key": Use a specific SSH key for one repository: essential when you manage multiple GitHub accounts.

Example: git config core.sshCommand "ssh -i ~/.ssh/deploy_key"

git config --global credential.helper store: Cache credentials in plain text so Git stops asking for your password on every push.

Example: git config --global credential.helper store

git config --global diff.tool vscode: Set a difftool so git difftool opens your editor for side-by-side diffs.

Example: git config --global diff.tool vscode

git config --global merge.tool vscode: Set a mergetool that opens your editor's merge view to resolve conflicts visually.

Example: git config --global merge.tool vscode

git config --global core.excludesfile ~/.gitignore_global: Point to a global gitignore for files you never want tracked in any repo (.DS_Store, Thumbs.db).

Example: git config --global core.excludesfile ~/.gitignore_global

Repositories

git init: Create a new empty repository in the current directory.

Example: git init

git init --bare repo.git: Create a bare repository: no working tree: for a central server or remote you never edit directly.

Example: git init --bare server.git

git clone <url>: Copy an existing remote repository to your machine with full history.

Example: git clone https://github.com/user/repo.git

git clone --depth 1 <url>: Shallow clone: only the latest commit. Use for CI, deployment, or huge repos.

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

git clone --branch <tag> <url>: Clone and check out a specific branch or tag immediately.

Example: git clone --branch v2.0.0 https://github.com/user/repo.git

git clone --recurse-submodules <url>: Clone a repo and initialize all its submodules in one step.

Example: git clone --recurse-submodules https://github.com/user/repo.git

git status: Show the working tree state: modified, staged, and untracked files. Run it constantly.

Example: git status

git status --short: Compact one-line-per-file status output: perfect for terminal muscle memory.

Example: git status --short

Staging & Committing

git add <file>: Stage a file: mark it to be included in the next commit.

Example: git add src/index.ts

git add .: Stage every change in the current directory (including deletions).

Example: git add .

git add -p: Stage changes interactively hunk-by-hunk: keep unrelated edits out of a commit.

Example: git add -p src/index.ts

git add -u: Stage only modified and deleted tracked files: never new untracked files.

Example: git add -u

git commit -m "message": Create a commit from staged changes with a message.

Example: git commit -m "fix: handle empty payloads"

git commit -am "message": Stage all tracked changes and commit in one step (untracked files are not included).

Example: git commit -am "refactor: extract client"

git commit --amend: Rewrite the last commit's message, or fold new staged changes into it. Never amend pushed commits.

Example: git commit --amend -m "feat: better message"

git commit --amend --no-edit: Add forgotten changes to the last commit without touching its message.

Example: git add . && git commit --amend --no-edit

git commit --fixup=<commit>: Create a fixup commit that autosquashes into another commit during rebase: tidy PR history.

Example: git commit --fixup=abc1234

git commit --squash=<commit>: Create a squash commit to merge into another during rebase --autosquash.

Example: git commit --squash=abc1234

git diff: Show unstaged changes: what would change if you committed right now.

Example: git diff

git diff --staged: Show staged changes: exactly what the next commit will contain.

Example: git diff --staged

git diff <file>: Show changes to a single file only.

Example: git diff src/index.ts

git diff HEAD: Show all changes: staged and unstaged: against the last commit.

Example: git diff HEAD

git diff --stat: Summarize changes with per-file line counts instead of full diffs.

Example: git diff --stat

git diff main...feature: Compare your feature branch against the point it diverged from main: ignores main's newer commits.

Example: git diff main...feature

Branching & Merging

git branch: List local branches; the * marks your current branch.

Example: git branch

git branch -a: List all branches including remote-tracking branches.

Example: git branch -a

git branch -vv: Show which remote each branch tracks and how far ahead/behind it is.

Example: git branch -vv

git branch <name>: Create a new branch at your current commit (does not switch to it).

Example: git branch feature/auth

git switch -c <name>: Create a branch and switch to it in one move: the modern replacement for checkout -b.

Example: git switch -c feature/auth

git switch <name>: Switch to an existing branch or remote-tracking branch.

Example: git switch main

git switch -: Switch back to the branch you were on before: like cd -.

Example: git switch -

git checkout <file>: Discard unstaged changes to a file, restoring it from the index.

Example: git checkout src/index.ts

git branch -d <name>: Delete a fully merged local branch. Use -D to force-delete unmerged work.

Example: git branch -d feature/auth

git merge <branch>: Merge another branch into your current branch, creating a merge commit.

Example: git merge feature/auth

git merge --no-ff <branch>: Force a merge commit even when a fast-forward is possible: keeps feature boundaries visible.

Example: git merge --no-ff feature/auth

git merge --abort: Abort a conflicted merge and restore the pre-merge state.

Example: git merge --abort

git rebase <branch>: Replay your commits on top of another branch for a linear history.

Example: git rebase main

git rebase -i HEAD~n: Interactive rebase: reword, reorder, squash, and drop commits in the last n.

Example: git rebase -i HEAD~3

git rebase -i --autosquash HEAD~n: Automatically fold fixup! and squash! commits into their targets during interactive rebase.

Example: git rebase -i --autosquash HEAD~5

git rebase --continue: Continue a rebase after resolving conflicts and staging the fixes.

Example: git rebase --continue

git rebase --abort: Cancel a rebase entirely and return to the pre-rebase state.

Example: git rebase --abort

git cherry-pick <commit>: Apply a single commit from another branch onto your current one: handy for hotfixes.

Example: git cherry-pick abc1234

git cherry-pick -n <commit>: Apply a commit without committing: stage several cherry-picks for one commit.

Example: git cherry-pick -n abc1234

git merge --squash <branch>: Merge a branch as a single squashed change staged for one commit.

Example: git merge --squash feature/auth

Inspecting & Comparing

git log: Show commit history with full details.

Example: git log

git log --oneline: One line per commit: hash plus subject. The default way to read history.

Example: git log --oneline

git log --oneline --graph --all: Visual branch graph across every branch: see how history actually forked and merged.

Example: git log --oneline --graph --all

git log --oneline -n 10: Show only the last 10 commits.

Example: git log --oneline -n 10

git log --author="jane" --oneline: Filter history by author: count your contributions or audit a teammate.

Example: git log --author="jane" --oneline

git log --since="2 weeks ago" --oneline: Show commits since a date: your weekly review.

Example: git log --since="2 weeks ago" --oneline

git log --grep="fix:" --oneline: Search commit messages for a pattern: find every fix commit.

Example: git log --grep="fix:" --oneline

git log -p <file>: Show the full patch history of a single file: find when a line changed.

Example: git log -p src/index.ts

git log -S "string" --oneline: Pickaxe search: find commits that added or removed a specific string (the infamous "where did this line come from").

Example: git log -S "apiKey" --oneline

git log -G "regex" --oneline: Find commits whose diff matches a regex: more flexible than -S.

Example: git log -G "TODO|FIXME" --oneline

git blame <file>: Show who changed each line and in which commit: the code archaeology tool.

Example: git blame src/index.ts

git show <commit>: Show a commit: its metadata and full diff.

Example: git show abc1234

git show HEAD: Show the latest commit on your branch.

Example: git show HEAD

git show HEAD~1:path/to/file: Show a file's contents at a past commit without checking it out.

Example: git show HEAD~1:src/index.ts

git reflog: Show every HEAD movement: your safety net to recover "lost" commits after resets.

Example: git reflog

git diff HEAD~1 HEAD: Compare the last commit against its parent.

Example: git diff HEAD~1 HEAD

git shortlog -sn: Summarize commits per author, sorted: your contribution report.

Example: git shortlog -sn

git count-objects -vH: Check repository size and object counts: when your .git is bloating.

Example: git count-objects -vH

git rev-parse HEAD: Print the full hash of the current commit: useful in scripts and CI.

Example: git rev-parse HEAD

git describe --tags: Describe the nearest tag to HEAD, e.g. v2.0.0-3-gabc1234: auto version labels.

Example: git describe --tags

Undoing Changes

git restore <file>: Discard unstaged changes in a file: restore it from the index.

Example: git restore src/index.ts

git restore --staged <file>: Unstage a file: keep changes in the working tree.

Example: git restore --staged src/index.ts

git restore --source=HEAD~1 <file>: Restore a file from a specific commit, discarding newer changes.

Example: git restore --source=HEAD~1 src/index.ts

git reset --soft HEAD~1: Undo the last commit but keep changes staged: fix a commit message or add more to it.

Example: git reset --soft HEAD~1

git reset HEAD~1: Undo the last commit and unstage changes (mixed reset: working tree keeps edits).

Example: git reset HEAD~1

git reset --hard HEAD~1: Undo the last commit AND discard its changes entirely. Dangerous: never on pushed history.

Example: git reset --hard HEAD~1

git reset --hard <commit>: Move the branch pointer and working tree to any commit: nuke everything after it.

Example: git reset --hard abc1234

git revert <commit>: Create a new commit that undoes another commit: the safe way to undo pushed history.

Example: git revert abc1234

git revert -n <commit>: Revert without committing: combine multiple reverts or adjust first.

Example: git revert -n abc1234

git clean -fd: Delete untracked files and directories: clean up build artifacts or stray files.

Example: git clean -fd

git clean -fdX: Delete only ignored files (build output, caches) while keeping untracked source.

Example: git clean -fdX

git update-ref -d HEAD: Delete the branch pointer entirely: start committing fresh in an empty repo.

Example: git update-ref -d HEAD

git bisect start && git bisect bad && git bisect good <commit>: Binary search history for the commit that introduced a bug.

Example: git bisect start; git bisect bad; git bisect good v1.0.0

git bisect run <script>: Automate bisecting: a script that exits 0 for good and nonzero for bad finds the culprit.

Example: git bisect run npm test

git bisect reset: Leave bisect mode and return to the original commit.

Example: git bisect reset

Remote Collaboration

git remote -v: List remotes with fetch and push URLs.

Example: git remote -v

git remote add origin <url>: Add a remote: typically your GitHub/GitLab repo.

Example: git remote add origin https://github.com/user/repo.git

git remote rename <old> <new>: Rename a remote, updating all tracking references.

Example: git remote rename origin upstream

git remote set-url origin <url>: Change a remote URL: e.g. when switching from HTTPS to SSH or moving a repo.

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

git remote remove <name>: Delete a remote and its tracking branches.

Example: git remote remove backup

git fetch origin: Download remote commits and branches without merging them.

Example: git fetch origin

git fetch --prune origin: Fetch and delete local refs for branches deleted on the remote.

Example: git fetch --prune origin

git pull: Fetch and merge remote changes into your current branch.

Example: git pull

git pull --rebase: Fetch and rebase local commits onto the remote: cleaner linear history.

Example: git pull --rebase

git push: Push committed changes to the remote tracking branch.

Example: git push

git push -u origin <branch>: Push a new branch and set upstream tracking: after this, plain git push works.

Example: git push -u origin feature/auth

git push --force-with-lease: Force-push only if nobody else pushed since your last fetch: the safe force.

Example: git push --force-with-lease

git push origin --delete <branch>: Delete a branch on the remote.

Example: git push origin --delete feature/auth

git push --tags: Push all local tags to the remote: releases and version markers.

Example: git push --tags

git push --all origin: Push every local branch to origin at once: sync after a fresh clone.

Example: git push --all origin

git ls-remote origin: List refs on a remote without cloning: check if a tag or branch exists.

Example: git ls-remote origin

git submodule add <url> <path>: Pin an external repo inside your repo at a fixed commit.

Example: git submodule add https://github.com/user/lib.git lib

git submodule update --init --recursive: Initialize and fetch all nested submodules after cloning or switching branches.

Example: git submodule update --init --recursive

git worktree add ../hotfix main: Check out another branch in a separate directory: work on two branches without stashing.

Example: git worktree add ../hotfix main

git worktree list: List all linked worktrees.

Example: git worktree list

git request-pull origin main https://github.com/user/repo: Generate a summary of changes to email to a maintainer when submitting patches.

Example: git request-pull origin main https://github.com/user/repo

Stashing

git stash: Save all uncommitted changes and clean the working tree: switch branches freely.

Example: git stash

git stash push -m "message": Stash with a label so you can identify it later.

Example: git stash push -m "wip: auth flow"

git stash push <file>: Stash only specific files: keep unrelated work in place.

Example: git stash push src/index.ts

git stash --keep-index: Stash working changes but keep staged changes: commit part of your work first.

Example: git stash --keep-index

git stash list: List all stashes with their labels and branch.

Example: git stash list

git stash apply: Reapply the latest stash but keep it in the list: apply to multiple branches.

Example: git stash apply

git stash pop: Reapply the latest stash and drop it from the list: normal workflow.

Example: git stash pop

git stash show -p stash@{1}: Preview a specific stash's diff before applying it.

Example: git stash show -p stash@{1}

git stash drop stash@{0}: Delete a stash permanently.

Example: git stash drop stash@{0}

git stash clear: Delete every stash: clean up an untidy stash list.

Example: git stash clear

git stash branch <name>: Create a branch from a stash's base commit and pop the stash onto it.

Example: git stash branch fix/typo

git stash -u: Stash untracked files too: not just tracked modifications.

Example: git stash -u

Tags & Releases

git tag: List all tags.

Example: git tag

git tag v1.0.0: Create a lightweight tag at the current commit.

Example: git tag v1.0.0

git tag -a v1.0.0 -m "Release v1.0.0": Create an annotated tag with a message: recommended for releases.

Example: git tag -a v1.0.0 -m "Release v1.0.0"

git tag -a v1.0.0 <commit>: Tag a past commit: release a hotfix on an old version.

Example: git tag -a v1.0.0 abc1234

git tag -d v1.0.0: Delete a local tag.

Example: git tag -d v1.0.0

git push origin --delete v1.0.0: Delete a tag on the remote.

Example: git push origin --delete v1.0.0

git checkout v1.0.0: Detach HEAD at a tag: inspect a release's exact code.

Example: git checkout v1.0.0

git show v1.0.0: Show the tagged commit and its diff.

Example: git show v1.0.0

git log v1.0.0..v2.0.0 --oneline: List all commits between two releases: write your changelog.

Example: git log v1.0.0..v2.0.0 --oneline

git tag --contains <commit>: Find which releases contain a specific commit.

Example: git tag --contains abc1234

Advanced History

git gc: Optimize the repository by compressing loose objects and pruning unreachable ones.

Example: git gc

git gc --aggressive --prune=now: Full housekeeping: do this when your .git folder is huge.

Example: git gc --aggressive --prune=now

git fsck --lost-found: Find dangling commits and objects: recover work after a botched reset.

Example: git fsck --lost-found

git filter-branch --force --index-filter "git rm --cached --ignore-unmatch .env" --prune-empty -- --all: Remove a file (like .env with secrets) from all of history: last resort, use filter-repo if available.

Example: git filter-branch --force --index-filter "git rm --cached --ignore-unmatch .env" --prune-empty -- --all

git replace <old> <new>: Temporarily substitute one commit for another: graft histories without rewriting.

Example: git replace abc1234 def5678

git archive --format=zip -o release.zip HEAD: Export the current commit as a zip without the .git folder.

Example: git archive --format=zip -o release.zip HEAD

git apply <patchfile>: Apply a diff patch file to the working tree.

Example: git apply changes.patch

git format-patch -1 HEAD: Generate a patch file for the last commit: email or share it without pushing.

Example: git format-patch -1 HEAD

git subtree add --prefix=lib <url> <branch>: Add a repository as a subtree: an alternative to submodules that inlines the code.

Example: git subtree add --prefix=lib https://github.com/user/lib.git main

git subtree pull --prefix=lib <url> <branch>: Pull upstream changes into a subtree.

Example: git subtree pull --prefix=lib https://github.com/user/lib.git main

Frequently asked questions

How do I undo the last commit?

Use git reset --soft HEAD~1 to undo the commit but keep your changes staged, git reset --mixed HEAD~1 (default) to unstage them, or git reset --hard HEAD~1 to discard everything. Never hard-reset commits that are already pushed.

What is the difference between git merge and git rebase?

Merge creates a new commit that combines two branch histories, preserving the original timeline. Rebase rewrites your branch on top of the target branch for a linear history. Use rebase for clean local history and merge for shared branches.

How do I unstage a file?

Run git restore --staged <file> (Git 2.23+) or git reset HEAD <file>. Your working directory changes are kept: only the staging area is updated.

How do I discard local changes to a file?

Run git restore <file> to revert a tracked file to the last commit. Use git stash to save changes temporarily instead of losing them, and git clean -fd to remove untracked files.