Developer Tools

Git Command Reference

Git is the version control system used by every professional developer. Track changes, collaborate with others, and never lose work again. Choose your level below.

Learning mode:

What is Git?

Git is a version control system. It tracks every change you make to your code files — who changed what, when, and why. If you break something, you can roll back. If you want to try something risky, you can branch off, experiment, and merge back if it works.

Git runs locally on your computer. GitHub is a website that hosts your Git repositories online so you can share them and collaborate with others.

Installing Git: Download from git-scm.com. After installing, open Terminal (Mac/Linux) or Git Bash (Windows) and type git --version to confirm it's working.

First-Time Setup

Before your first commit, tell Git who you are. This name and email will appear in your commit history.

Shell — Git Setup

git config --global user.name "Your Name" git config --global user.email "you@example.com" git config --global core.editor "code --wait"

Starting a Repository

git init

Creates a new Git repository in the current folder. Run this once when starting a new project.

git clone <url>

Downloads an existing repository from GitHub (or any remote) to your computer.

Shell — Starting a project

mkdir my-project && cd my-project git init git clone https://github.com/username/repo-name.git

The Daily Workflow

Every day you'll use these four commands. They form the core loop of working with Git: check what changed, stage it, commit it, push it.

git status

Shows which files have changed, which are staged, and which are untracked. Run this constantly.

git add <file>

Stages a specific file for the next commit. Use git add . to stage everything.

git commit -m "message"

Saves staged changes as a snapshot with a description. Write clear, present-tense messages.

git push

Uploads your local commits to the remote repository (GitHub). Others can then see your changes.

git pull

Downloads and applies the latest changes from the remote. Always pull before starting new work.

git log

Shows the commit history — who committed what and when. Press Q to exit.

Shell — Daily workflow

git pull git status git add index.html styles.css git commit -m "Add hero section and fix nav styles" git push

Ignoring Files

Create a file called .gitignore in your project root. List files and folders you never want to commit — like node_modules/, .env files, or OS files like .DS_Store.

.gitignore — Common entries

node_modules/ .env .env.local .DS_Store dist/ *.log

Next step: Try Intermediate mode to learn about branching — how to work on features without breaking your main code.

Branching

Branches let you work on a feature or fix without affecting the main codebase. You create a branch, make commits on it, and when you're done, merge it back.

git branch

Lists all local branches. The active branch has an asterisk (*) next to it.

git branch <name>

Creates a new branch. Does not switch to it — you're still on the current branch.

git checkout <name>

Switches to a different branch. Your working directory updates to match that branch.

git checkout -b <name>

Creates a new branch AND switches to it in one command. The shortcut you'll use most.

git merge <name>

Merges the named branch into your current branch. Switch to main first, then merge.

git branch -d <name>

Deletes a branch after it's been merged. Use -D to force-delete unmerged branches.

Shell — Feature branch workflow

git checkout main git pull git checkout -b feature/contact-form git add . git commit -m "Add contact form with validation" git push -u origin feature/contact-form git checkout main git merge feature/contact-form git branch -d feature/contact-form

Viewing Changes

git diff

Shows line-by-line changes in unstaged files. Green = added, red = removed.

git diff --staged

Shows changes that are staged (added with git add) but not yet committed.

git log --oneline

Compact commit history — one line per commit. Great for scanning recent changes.

git log --graph --oneline

Shows a visual ASCII graph of your branch history alongside the log.

git show <hash>

Shows the full diff and metadata for a specific commit. Use the first 7 characters of the hash.

git blame <file>

Shows who last modified each line of a file and when. Useful for tracking down changes.

Stashing

If you need to switch branches but aren't ready to commit, git stash saves your changes temporarily.

git stash

Saves all uncommitted changes and cleans your working directory. Your code is safe.

git stash pop

Restores the most recently stashed changes back into your working directory.

git stash list

Shows all stashed changesets. Multiple stashes stack up like a list.

git stash drop

Deletes the most recent stash without applying it. Use when you no longer need it.

Remotes

git remote -v

Lists all remote connections (name + URL). Usually shows origin pointing to GitHub.

git remote add origin <url>

Connects your local repository to a remote URL. Run this after git init.

git fetch

Downloads remote changes but does NOT apply them. Safe way to see what's new before merging.

git push -u origin main

Pushes to remote and sets origin/main as the default upstream. After this, just use git push.

Rebase

Rebase rewrites commit history to create a cleaner, linear timeline. Instead of a merge commit, your commits appear as if they were made directly on top of the target branch.

git rebase main

Replays your current branch's commits on top of main. Keeps history linear.

git rebase --abort

Cancels a rebase in progress and returns to the pre-rebase state. Use when conflicts get messy.

git rebase --continue

After resolving a conflict during rebase, stage changes and run this to continue.

Rule: Never rebase commits that have been pushed to a shared branch. Rebase rewrites history — others' repos will diverge.

Reset and Undo

Git has three reset modes. Know which one to use — --hard destroys work.

git reset --soft HEAD~1

Undoes the last commit, keeps changes staged. Use when you committed too early.

git reset --mixed HEAD~1

Undoes the last commit, unstages changes. Files remain modified. The default reset mode.

git reset --hard HEAD~1

Undoes the last commit and discards all changes. Destructive — cannot be undone easily.

git revert <hash>

Creates a new commit that undoes a previous commit. Safe for shared branches — history is preserved.

git restore <file>

Discards unstaged changes to a specific file. Destructive for that file's unsaved work.

Cherry-Pick and Reflog

git cherry-pick <hash>

Applies a specific commit from another branch to your current branch. Useful for backporting fixes.

git reflog

Shows every action Git recorded, including resets and rebases. Your safety net for recovering lost commits.

Shell — Recovering lost commits with reflog

git reflog # Find the commit hash before the bad reset git checkout -b recovery abc1234

Aliases and Productivity

Shell — Useful Git aliases

git config --global alias.st status git config --global alias.co checkout git config --global alias.lg "log --oneline --graph --decorate --all" git config --global alias.undo "reset --soft HEAD~1"

.gitignore Patterns

.gitignore — Pattern reference

*.log # all .log files anywhere logs/ # entire logs/ directory !important.log # exception — track this file despite *.log above **/temp # any folder named temp at any depth doc*.pdf # all .pdf files anywhere under doc/

Tip: Use gitignore.io to generate .gitignore files for any language or framework automatically.