Git & GitHub Guide

mkdir my-project
cd my-project
git initCopy

This creates a hidden .git folder inside your project. Now Git is tracking everything in this directory. Run ls -la to see the .git folder — that's Git's "brain". Don't touch it manually!

git clone https://github.com/user/repo.git
# or with SSH (no password each time):
git clone git@github.com:user/repo.gitCopy

This downloads the entire project history to your computer. You get everything — all files, all branches, all commits.

git statusCopy

This is the most-used Git command. It tells you which files are modified but not staged, which files are staged ready to commit, and which files are untracked (new files Git doesn't know about).

git add filename.txt       # stage one specific file
git add .                  # stage ALL changes
git add -p                 # stage interactively — pick what to includeCopy

Staging is like picking which items to put in a photo before taking the picture. You don't have to commit everything.

git commit -m "Add login button"
git commit -am "Fix typo"   # shortcut: add + commit (tracked files only)Copy

Every commit has a message describing what changed. Write clear messages so your future self (and others) understand why.

git log                      # full history
git log --oneline            # compact (one line per commit)
git log --oneline --graph    # show branch structure visually
git log --oneline -5         # last 5 commits only
git log --author="Laksh"   # commits by a specific personCopy

git show HEAD                # show the latest commit
git show abc1234             # show a specific commit (use its hash)
git show HEAD~2              # show what changed 2 commits agoCopy

git diff                     # unstaged changes (working dir vs staging)
git diff --staged            # staged changes (vs last commit)
git diff HEAD~1..HEAD        # changes between two commits
git diff branch-a..branch-b  # compare two branchesCopy

git shortlog                 # shows commits grouped by author
git shortlog -sn             # same but with commit count onlyCopy

git blame README.md          # shows who last touched each line
git blame -L 10,20 src/app.js  # lines 10-20 onlyCopy

Useful when you find a bug and want to ask "who wrote this line?" (including your past self).

git grep "search-term"       # search all tracked files
git grep "TODO"              # find all TODOs in your projectCopy

Faster than regular grep because it only searches tracked files.

git check-ignore -v some-file.logCopy

Shows which rule in .gitignore is ignoring that file.

git restore filename.txt           # discard changes in working directory
git restore .                      # discard all unstaged changes
# Older syntax (still works):
git checkout -- filename.txtCopy

⚠ This permanently discards unsaved work in that file. You cannot get it back!

git restore --staged filename.txt   # unstage, but keep file changes
git restore --staged .              # unstage everythingCopy

Your file changes are preserved — they just move out of the staging area back to your working directory.

# Soft — undo commit, keep changes staged
git reset --soft HEAD~1

# Mixed (default) — undo commit, unstage changes
git reset HEAD~1

# Hard — DESTROY everything after the target commit ⚠
git reset --hard HEAD~1Copy

HEAD~1 = "one commit before HEAD". Use HEAD~n for n commits, or a full commit hash like abc1234. --hard permanently deletes uncommitted changes and commits. Only use it on commits you haven't shared.

git revert HEAD                  # create a new commit that undoes HEAD
git revert abc1234               # undo a specific commit by hashCopy

Unlike reset, revert does not delete history. It makes a new commit that cancels out the old one. Safe to use on shared branches!

git clean -n                  # preview what would be deleted (dry run)
git clean -f                  # delete untracked files
git clean -fd                 # delete untracked files + directoriesCopy

Always run git clean -n first to see what will be removed!

git branch                     # list local branches (* = current)
git branch feature-x           # create a new branch called feature-x
git branch -m old new          # rename a branch
git branch -d feature-x        # delete branch (only if merged)
git branch -D feature-x        # force delete (unmerged work!)Copy

git switch feature-x           # switch to existing branch
git switch -c new-branch       # create AND switch to new branch
git switch -                   # switch back to previous branchCopy

git branch -a                  # list all branches
git branch -r                  # remote branches onlyCopy

# First, switch to the branch you want to merge INTO
git switch main

# Then merge the feature branch into main
git merge feature-x

# Force a merge commit (even if fast-forward is possible)
git merge --no-ff feature-xCopy

# While on your feature branch:
git switch feature-x
git rebase main
# Now your commits sit on top of main's latest commitCopy

# Edit the last 3 commits before pushing:
git rebase -i HEAD~3

# Inside the editor, you can:
#   pick    — keep the commit as-is
#   reword  — change the commit message
#   squash  — combine with previous commit
#   edit    — pause to make changes
#   drop    — delete the commitCopy

This is how you clean up messy commit history before sharing it.

git rebase --abort   # go back to before you started rebasingCopy

# First push (set upstream):
git push -u origin main

# Subsequent pushes (just):
git push

# Push a specific branch:
git push origin feature-x

# Delete a remote branch:
git push origin --delete feature-xCopy

git pull origin main           # fetch + merge latest changes
git pull                       # if upstream is configuredCopy

git pull is a shortcut for git fetch + git merge. It downloads changes and immediately merges them.

git fetch origin               # download changes, DON'T merge
git fetch --prune              # remove stale remote-tracking branches
git diff main origin/main      # see what changed before mergingCopy

Use fetch when you want to review changes before integrating them.

origin     https://github.com/YOU/repo.git (fetch)
origin     https://github.com/YOU/repo.git (push)
upstream   https://github.com/OWNER/repo.git (fetch)
upstream   https://github.com/OWNER/repo.git (push)Copy

origin = your fork, upstream = the original repo you forked from.

git reflog                   # shows EVERYTHING you've done
# Output like:
# abc1234 HEAD@{0}: commit: Fix login
# def5678 HEAD@{1}: reset: moving to HEAD~1

# Recover a "lost" commit:
git reset --hard HEAD@{2}    # go back to that pointCopy

The reflog is Git's local journal of every action you've taken. Even after a git reset --hard or git rebase, you can find your old commits here. Your reflog expires after ~90 days.

# Start bisecting:
git bisect start

# Mark the current commit as bad:
git bisect bad

# Mark an old commit (that you know worked) as good:
git bisect good abc1234

# Git checks out a commit halfway in between.
# Test it, then mark:
git bisect good   # if it works
git bisect bad    # if it's broken

# Git narrows it down to one commit. When done:
git bisect resetCopy

git bisect uses binary search to find the exact commit where a bug was introduced. For 1000 commits, it takes only ~10 steps!

GitHub Actions runs tasks automatically when events happen — like running tests on every push.

# .github/workflows/test.yml — example
name: Run tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm install
      - run: npm testCopy

Common use cases: run tests, deploy to a server, lint code, publish packages.

GitHub Pages serves static websites directly from a repository. Great for docs, portfolios, project sites.

• Go to repo → Settings → Pages
• Select branch (usually main or gh-pages)
• Your site is live at https://username.github.io/repo-name

GitHub Projects is a built-in project management board (like Trello) linked to issues and PRs.

• Create columns: To Do → In Progress → Done
• Drag issues and PRs between columns
• Automate with Actions (e.g., move to "Done" when PR merges)

Install gh and never leave the terminal:

gh repo create my-repo        # create a repo on GitHub
gh pr create                  # create a pull request
gh pr checkout 42             # checkout PR #42 locally
gh issue list                 # list open issues
gh repo view                  # view repo detailsCopy

Install: brew install gh (macOS), sudo apt install gh (Linux), or download from cli.github.com.

# Add a submodule
git submodule add https://github.com/user/library.git lib/library

# Clone a repo WITH its submodules
git clone --recurse-submodules https://github.com/user/project.git

# Update submodules to their latest commit
git submodule update --remoteCopy

Submodules let you keep a Git repo as a dependency inside another Git repo.

# Create a zip of your project (no .git folder)
git archive --format=zip HEAD > project.zip

# Create a tar.gz
git archive --format=tar.gz -o project.tar.gz HEADCopy

Perfect for sharing a clean copy of your code — no .git history, no ignored files.

# Check out a branch in a separate directory
git worktree add ../project-hotfix hotfix-branch

# List worktrees
git worktree list

# Remove a worktree when done
git worktree remove ../project-hotfixCopy

Lets you have two different branches checked out at the same time in different folders — no stashing or switching needed.