Git Cheat Sheet

Turns the current directory into a Git repository by creating a hidden .git folder. Run it once, in the project's root.

Copies an existing remote repository — history, branches, and all — into a new folder on your machine, and automatically wires up 'origin' as its remote.

Sets the name attached to every commit you make on this machine. Without this (and user.email), Git refuses to commit.

Sets the email attached to every commit. Use the same address as your GitHub/GitLab account if you want commits linked to your profile.

Git still defaults new repos to 'master' unless you set this. Run it once and every future git init uses 'main' instead.

Shows what's changed, what's staged, and what's untracked. Run this before every add and every commit — it's the single habit that prevents the most 'oops' commits.

Stages a file so it will be included in the next commit. git add . stages everything changed in the current directory — convenient, but easy to accidentally include files you didn't mean to.

Walks through your changes hunk by hunk, letting you stage part of a file instead of all of it. The right tool when one file has both a real fix and an unrelated debug print you don't want to commit.

Records everything currently staged as a new, permanent point in history.

Stages every already-tracked, modified file and commits in one step. Skips git add — but it will not pick up brand-new (untracked) files, which is a common source of 'why isn't my new file in the commit?'

Shows exactly what changed in your working directory, line by line, since the last commit — the unstaged version.

Same idea, but shows only what's staged — i.e. exactly what git commit would record if you ran it right now. Run this instead of git diff right before committing.

A compact, one-line-per-commit view of history across every branch, with ASCII branch lines — the fastest way to see how branches relate to each other at a glance.

Lists local branches, with an asterisk next to the one you're currently on.

Creates a new branch called feature-x from your current commit and switches to it immediately. The modern, purpose-built replacement for git checkout -b feature-x.

Switches to an already-existing branch. On Git older than 2.23, use git checkout main instead — same effect, older syntax.

Jumps back to whichever branch you were on before your last switch — the Git equivalent of cd - in a shell.

Merges feature-x into your current branch. If your branch hasn't diverged, Git does a 'fast-forward' (just moves the pointer); otherwise it creates a new merge commit tying both histories together.

Deletes a local branch — but only if it's already fully merged somewhere, as a safety check.

Force-deletes a branch regardless of merge status. Capital -D skips the safety check — make sure you actually meant to throw that work away.

Renames a branch. If you've already pushed the old name, you'll also need to push the new one and delete the old remote branch.

Lists every remote Git knows about and the URLs it fetches from / pushes to. Almost every repo has exactly one, named 'origin'.

Registers a remote named origin — needed if you ran git init locally instead of git clone, and now want to connect it to GitHub/GitLab/etc.

Downloads new commits and branches from the remote into your local copy — but does not touch your working files or current branch. Always safe to run.

Shorthand for git fetch followed immediately by git merge — brings your current branch up to date with its upstream, creating a merge commit if you'd diverged.

Same idea, but replays your local commits on top of the fetched ones instead of merging — keeps history linear instead of accumulating small 'merge branch main' commits on a branch only you use.

Uploads your local feature-x branch and its commits to the remote.

Pushes and remembers the link between your local branch and origin/feature-x, so every future push or pull on this branch can drop the branch name entirely.

Replaces your most recent commit with a new one — opens your editor to change the message, and includes whatever's currently staged as additional changes.

Same as above, but keeps the existing commit message — useful for 'oops, forgot to stage this file' right after committing.

Replays every commit on your current branch, one by one, on top of main's latest commit — as if you'd branched off just now instead of days ago.

Opens an editable to-do list of your last 3 commits, letting you reorder, reword, squash together, or drop them entirely before continuing.

Applies one specific commit from anywhere in the repo onto your current branch — handy for pulling a single hotfix out of a branch without merging the whole thing.

Moves your branch pointer back one commit but leaves all its changes staged, ready to re-commit — use when the code was right but the commit itself wasn't (bad message, should've been split up).

Moves your branch pointer back one commit and throws away its changes completely, in both the index and your working files. There is no undo dialog — see the Undoing Mistakes section if you didn't mean it.

Creates a brand-new commit that applies the exact opposite of a previous commit, leaving all existing history untouched. The correct way to 'undo' something that's already been pushed and possibly pulled by others.

Discards uncommitted changes to a file, reverting it to how it looked at the last commit. The modern replacement for git checkout -- <file>.

Unstages a file — moves it back to 'modified, not staged' — without touching its actual contents. What you want when git add caught more than you meant it to.

Shows a chronological log of every position HEAD has ever pointed to on this machine, including commits a reset --hard or a rebase seemingly 'deleted.' Those commits are still there until Git eventually garbage-collects them.

Once you've found the lost commit's position in git reflog, this snaps your branch straight back to it, undoing an accidental reset or rebase.

Shelves all uncommitted changes (staged and unstaged) into a temporary slot and gives you a clean working directory — for when you need to switch branches right now but aren't ready to commit.

Reapplies the most recently stashed changes to your working directory and removes them from the stash list. Use git stash apply instead if you want to keep the stash around as a backup.

Dry-runs a cleanup of untracked files and directories — prints exactly what would be deleted without deleting anything. Drop the -n (leaving just -fd) only once you've read that list and are sure.

Shows the complete commit history of a single file, including the full diff at every change — the file's biography.

Annotates every line of a file with the commit and author who last changed it. The starting point for 'why is this line here' archaeology.

Displays one commit's full metadata (author, date, message) plus the diff it introduced.

Searches every tracked file in the repo for a string or regex — faster than a filesystem-wide grep since it only looks at what's checked into Git.

Begins a binary search through history for the exact commit that introduced a bug. Mark a known-bad commit and a known-good one, and Git checks out the midpoint for you to test — repeat until it narrows down to a single commit.

Creates an annotated tag — stores its own author, date, and message, and is what git describe and most release tooling expect. Use this over a lightweight tag for anything you'll actually ship.

Creates a lightweight tag — just a named pointer to a commit, with no extra metadata. Fine for quick personal bookmarks, not ideal for public releases.

Tags aren't pushed automatically with git push — you have to push them explicitly, one at a time, or all at once with --tags below.

Pushes every local tag that isn't already on the remote, in one command.

Deletes a tag locally only. Pair with the next command if it's already been pushed.

Deletes a tag from the remote. Deleting a tag doesn't delete the commit it pointed to — just the bookmark.

Creates git st as a shorthand for a compact status. Once set, aliases work exactly like built-in commands.

Creates git co as a shorthand for git switch — a habit carried over from the git checkout era that still saves keystrokes.

Turns the long visual-history command from the Basics section into a two-letter git lg.

A one-word safety net for the single most common 'wait, undo that commit' moment — see the Rewriting History section for what --soft actually preserves.

Points Git at a personal, machine-wide .gitignore for editor files, OS clutter (.DS_Store, Thumbs.db), and other things that have nothing to do with any specific project — so you never have to add them to a project's own .gitignore.