Git & GitHub cheat sheet

• A commit is a snapshot of the whole project, with a parent, an author, a message and a hash.
• A branch is a movable label on a commit. HEAD says which branch (or commit) you are on.
• Work moves through three places: working tree → staging area (add) → repository (commit).
• Git compares by hash, so equal content has an equal hash, and history cannot change silently.

git status

What changed, what is staged

git add -p

Stage piece by piece (small commits)

git commit -m "msg"

Save the staged snapshot

git diff

Unstaged changes

git diff --staged

What the next commit will contain

git log --oneline --graph

Short history with branches

git log -S"text"

Find commits that added or removed text

git show HASH

One commit in full

Tip: Small commits with a clear message make every later tool (bisect, revert, review) easier.

• First line: short (about 50 characters), in the imperative: "Fix login redirect".
• Blank line, then the why if it is not obvious. The diff already shows the what.
• One idea per commit. If the message needs "and", it is probably two commits.
• Put build output, secrets and editor files in .gitignore before the first add.

git switch -c NAME

Create a branch and move to it

git switch NAME

Move to an existing branch

git branch -d NAME

Delete a merged branch

git merge NAME

Join NAME into the current branch

git merge --abort

Back out of a merge in trouble

1. git status lists the files marked "both modified".
2. Open each file and find the <<<<<<<, ======= and >>>>>>> markers.
3. Keep the right lines, delete the three marker lines, and save.
4. git add FILE, then git commit (or git merge --continue).
5. Run the tests. Keep branches short-lived so conflicts stay small.

git remote -v

Show the remotes and their URLs

git fetch

Download new commits, change nothing locally

git pull

fetch plus a merge into your branch

git pull --rebase

fetch plus a rebase (straighter history)

git push -u origin NAME

Send a branch and remember it

git push

Send the current branch

Tip: When unsure, fetch first. It is always safe, and you can look before you merge.

1. Branch from an up-to-date main, make small commits, push the branch.
2. Open the pull request. Say what changed, why, how you tested it, and what to look at.
3. Reviewers comment. Answer every comment, push fixes as new commits.
4. Merge (merge commit, squash or rebase, as the team chose), then delete the branch.

Watch out: --hard throws away uncommitted work. If you already committed it, git reflog can still find it.

git cherry-pick HASH

Copy one commit onto this branch

git bisect start

Begin a binary search for a bad commit

git bisect good / bad

Tell it how each checked commit behaves

git bisect reset

Finish and return to your branch

git reflog

Every place HEAD has been (your safety net)

• git rebase main replays your commits on top of the new main: a straight line, new hashes.
• git rebase -i HEAD~N lets you squash, reword, drop or reorder your last N commits.
• Rebase only commits nobody else has. Rewriting shared history breaks other people's copies.
• After a rebase you must force push: use git push --force-with-lease, never plain --force.

git switch feature
git rebase main
# fix any conflicts, then:
git rebase --continue
git push --force-with-lease

• Branch protection on main: require a pull request, passing checks and a review.
• CODEOWNERS names who must review which paths, so changes reach the right people.
• GitHub Actions runs tests on every push: a file in .github/workflows/ with on, jobs, steps.
• Pick one workflow (merge, squash or rebase) and write it down, so history stays consistent.