Foundations
Git and GitHub manage source code and collaboration workflows.
On this page
Use this page for fast recall. Use Full documentation when you want the complete end-to-end path.
A simple 5-step flow you can follow when using Git & GitHub in real work.
1) Setup
Install/run the tool and confirm version. Create a minimal config.
2) Small change
Do one small action end-to-end to prove the workflow.
3) Validate
Check output, logs, and status. Catch mistakes early.
4) Automate
Convert it into a repeatable script or pipeline step.
5) Productionize
Add safety: secrets, rollback, observability, and docs.
These are practical sequences you can copy into your own checklist or runbook.
Goal: Ship changes with reviewable history and minimal conflicts.
- Create a feature branch from `main`.
- Commit small, logical changes with clear messages.
- Rebase onto latest `main` before opening PR (or before merge).
- Request review, address feedback, keep PR focused.
- Merge using your team’s strategy (merge commit, squash, or rebase).
- Commits
- Branches
- Pull requests
Learning path (high-level):
- Basic git flow
- Branching strategy
- Code review process
Initialize repository
Command
git initAdd and commit changes
Command
git add . && git commit -m 'init'Push to remote
Command
git push origin mainShort descriptions and practical intent. Search, filter, copy, and reuse.
Showing 25
git statusShow changed files and branch status.
git diffSee unstaged changes.
git diff --stagedSee staged changes.
git add .Stage all changed files.
git add -pStage changes interactively (best practice).
git commit -m "msg"Create a commit from staged changes.
git commit --amendEdit last commit (before pushing).
git log --oneline --decorate --graph -n 20Readable recent history.
git show <sha>Inspect a commit.
git branch -vvShow local branches and upstream tracking.
git checkout -b feature/xCreate and switch to a new branch.
git switch -c feature/xModern alternative to checkout (create branch).
git switch -Toggle to previous branch.
git fetch --all --pruneUpdate refs and delete removed remote branches.
git pull --rebaseUpdate branch with a clean history.
git push -u origin HEADPush current branch and set upstream.
git push --force-with-leaseSafer force push (protects others’ work).
git stash push -m "wip"Temporarily save changes.
git stash popRe-apply stashed changes.
git rebase -i HEAD~3Interactive rebase to squash/clean commits.
git reset --soft HEAD~1Undo last commit but keep changes staged.
git reset --hard HEADDiscard local changes (danger).
git revert <sha>Create a new commit that undoes a commit (safe for shared branches).
git tag -a v1.0.0 -m "release"Create an annotated tag.
git push origin --tagsPush tags to remote.
Small blocks you can drop into your terminal, config, or runbook.
Create a feature branch and push upstream
bash
git switch -c feature/my-change
# work...
git add -p
git commit -m "feat: add X"
git push -u origin HEADSquash last 3 commits into 1
bash
git rebase -i HEAD~3
# mark commits as squash, save/exitWhen things break, follow this order to stay calm and move fast.
- If you have conflicts: understand the conflicting files, fix markers, then `git add` and continue rebase/merge.
- If you pushed secrets: rotate credentials, remove from history (BFG/filter-repo), and force push carefully.
- If your branch is behind: `git fetch --all` then rebase/merge from `origin/main`.
The common mistakes that slow people down when using Git & GitHub.
- Force-pushing to shared branches without communicating.
- Not pulling/rebasing before pushing, causing messy histories.
- Committing secrets (use `.gitignore` and secret scanning).
Do these tasks in order. You will feel the tool instead of just reading about it.
- Create a feature branch, make 2 commits, then squash them into 1 clean commit.
- Resolve a merge conflict intentionally (edit the conflict markers, then commit).
- Tag a release and push the tag to remote.
Use these to test if you truly understand the basics (and can explain them clearly).
- When do you use rebase vs merge, and why?
- How do you recover from a bad commit pushed to remote?
- Describe a branching strategy you’ve used and its tradeoffs.