Git commands: an everyday cheat sheet with examples

Below is a practical Git cheat sheet: commands are grouped by task, each with an example and a short explanation. It's handy to keep open next to your terminal: nearly everything a developer does with Git in a day fits into 20–30 commands from these tables.

To make sense of the commands, keep three areas in mind: the working directory (files on disk), the index or staging area (what goes into the next commit), and the repository (the commit history in the .git folder). Most Git commands move changes between these three areas or between your local and a remote repository.

Setting up Git

You run these once after installing. The --global flag writes settings to ~/.gitconfig and applies them to all of your repositories; without it, they apply to the current repository only.

Creating and cloning a repository

The basic loop: status, add, commit

This is the core of daily work: see what changed, stage what you need, and record it in a commit.

A typical workflow looks like this:

git status
git add src/login.js src/login.css
git diff --staged          # check exactly what goes into the commit
git commit -m "Add login form"

Don't use --amend on commits you've already pushed to a shared branch: it creates a new commit with a different hash, and your teammates will have to deal with diverged history.

Viewing history and changes

Commit references come in handy everywhere: HEAD is the current commit, HEAD~1 is its parent, HEAD~3 is three steps back along the first parent, and HEAD^2 is the second parent of a merge commit.

Branches: create, switch, delete

Since version 2.23, Git has git switch for branches and git restore for files — they split up the overloaded git checkout. The old forms still work.

Merging and rebasing

Resolving a merge conflict almost always looks the same:

git merge feature
# CONFLICT (content): Merge conflict in app.js
git status                 # files listed under "both modified"
# edit app.js, remove the <<<<<<< ======= >>>>>>> markers
git add app.js
git commit                 # Git suggests a ready-made merge commit message

The golden rule of rebase: don't rebase commits that are already on a shared branch where others are building on them.

Working with remote repositories

Instead of git push --force, get used to --force-with-lease: if a teammate has pushed to the same branch in the meantime, the command refuses to overwrite their work.

Undoing changes

The most nerve-racking part of Git. The key question before picking a command: are the changes only in your files, already staged, in a local commit, or in a published commit?

git reset --hard and git clean -f permanently delete uncommitted changes: the reflog only keeps commits, not edits in the working directory. Run git stash first, or at least git status.

Stash: set unfinished work aside

Tags and releases

Advanced Git commands

Common mistakes and how to fix them

Committed to main instead of a new branch

If the commit hasn't been pushed yet, create a branch at the current commit and roll main back:

git branch feature/login      # the branch points to your commit
git reset --hard HEAD~1       # main goes back one step
git switch feature/login

Forgot to add a file to the last commit

git add forgotten.js
git commit --amend --no-edit

Push rejected: non-fast-forward

The server has commits you don't. Pull them first, then push:

git pull --rebase
git push

Accidentally committed a file with passwords

Stop tracking it and add it to .gitignore: git rm --cached .env, then commit. If the commit has already been pushed, consider the secret compromised and rotate it — it's still in the history.

Summary

A short set covers day-to-day work: status, add, commit, switch, merge, pull, push and log --oneline. Choose among the undo commands — restore, reset, revert — based on whether the commit has been published, and remember reflog as your last-resort safety net. All the Git commands in this cheat sheet are covered hands-on in the Git course, where you try each one in your own repository.