The Complete Git Workflow Guide: From Beginner to Advanced

# Initialize a new repository
git init

# Check the status of all three areas
git status

# Move changes from Working Directory → Staging Area
git add file.js              # stage a specific file
git add src/                # stage an entire directory
git add -p                   # interactively stage hunks

# Move changes from Staging Area → Repository
git commit -m "Add user authentication"

# View commit history
git log --oneline --graph

# View changes in working directory (unstaged)
git diff

# View changes in staging area (staged, ready to commit)
git diff --staged

# Required: your name and email (used in commit metadata)
git config --global user.name "Your Name"
git config --global user.email "you@example.com"

# Recommended: default branch name
git config --global init.defaultBranch main

# Recommended: auto-setup rebase on pull
git config --global pull.rebase true

# Recommended: colorized diff output
git config --global core.pager "delta"

# Set default editor
git config --global core.editor "code --wait"

# Useful aliases
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.st status
git config --global alias.lg "log --oneline --graph --all"

# Dependencies
node_modules/
vendor/
.venv/

# Build output
dist/
build/
.next/

# Environment & secrets
.env
.env.local
*.pem

# OS files
.DS_Store
Thumbs.db

# IDE
.idea/
.vscode/
*.swp

# Logs
*.log
npm-debug.log*

# Start a feature
git checkout develop
git checkout -b feature/user-auth

# Work on the feature, commit regularly
git add . && git commit -m "Add login form component"
git add . && git commit -m "Add JWT token validation"

# Finish feature: merge back to develop
git checkout develop
git merge --no-ff feature/user-auth
git branch -d feature/user-auth

# Create a release
git checkout -b release/1.2.0 develop
# ... fix bugs, bump version ...
git checkout main && git merge --no-ff release/1.2.0
git tag -a v1.2.0 -m "Release 1.2.0"
git checkout develop && git merge --no-ff release/1.2.0

# Emergency hotfix
git checkout -b hotfix/critical-fix main
# ... fix the issue ...
git checkout main && git merge --no-ff hotfix/critical-fix
git checkout develop && git merge --no-ff hotfix/critical-fix

# The entire GitHub Flow workflow:

# 1. Create a branch from main
git checkout main
git pull origin main
git checkout -b feature/add-search

# 2. Make commits
git add . && git commit -m "Add search component"

# 3. Push and open a Pull Request
git push -u origin feature/add-search
gh pr create --title "Add search functionality"

# 4. Review, discuss, iterate
# 5. Merge via GitHub UI (squash merge recommended)
# 6. Deploy automatically from main

# Trunk-Based: short-lived branches (max 1-2 days)

# Pull latest main
git checkout main && git pull

# Create a short-lived branch
git checkout -b short/add-button

# Make a small, focused change
git add . && git commit -m "Add submit button to form"

# Push and merge same day
git push -u origin short/add-button
# PR → Review → Merge → Delete branch

# Feature flags for incomplete features:
# if (featureFlags.newSearch) { showNewSearch() }

# Merge feature branch into main
git checkout main
git merge feature/add-search

# --no-ff forces a merge commit even if fast-forward is possible
git merge --no-ff feature/add-search

# Rebase feature branch onto latest main
git checkout feature/add-search
git rebase main

# Interactive rebase to clean up commits before merging
git rebase -i main
# In the editor, you can:
# pick   - keep the commit
# squash - combine with previous commit
# reword - change the commit message
# drop   - remove the commit entirely
# edit   - pause to amend the commit

# Before opening a PR: rebase onto latest main
git checkout feature/my-feature
git fetch origin
git rebase origin/main

# If conflicts, resolve them, then:
git add .
git rebase --continue

# Force push (safe because only you work on this branch)
git push --force-with-lease

// This is what a conflict looks like in your file:

<<<<<<< HEAD
const theme = 'dark';
=======
const theme = 'light';
>>>>>>> feature/light-mode

// HEAD = your current branch's version
// feature/light-mode = the incoming branch's version
// You choose: keep one, keep both, or write something new

# 1. See which files have conflicts
git status

# 2. Open the conflicted file, resolve manually
#    Remove the <<<<<<, =======, >>>>>>> markers
#    Keep the correct code

# 3. Mark as resolved by staging
git add conflicted-file.js

# 4. Continue the merge or rebase
git merge --continue    # if merging
git rebase --continue   # if rebasing

# If it gets messy, abort and start over
git merge --abort
git rebase --abort

# Use a visual merge tool
git mergetool

# Hooks live in .git/hooks/ (local, not committed)
# Use Husky to manage hooks via package.json (committed)

# Install Husky
npx husky init

# Create a pre-commit hook that runs linting
echo "npx lint-staged" > .husky/pre-commit

# Create a commit-msg hook for conventional commits
echo "npx commitlint --edit \$1" > .husky/commit-msg

#!/bin/sh

# Run lint-staged (only checks staged files)
npx lint-staged

# Run type checking
npx tsc --noEmit

{
  "lint-staged": {
    "*.{js,ts,jsx,tsx}": [
      "eslint --fix",
      "prettier --write"
    ],
    "*.css": [
      "stylelint --fix",
      "prettier --write"
    ],
    "*.md": [
      "prettier --write"
    ]
  }
}

# Stash current changes (both staged and unstaged)
git stash

# Stash with a descriptive name
git stash push -m "WIP: auth refactor"

# Include untracked files
git stash -u

# List all stashes
git stash list

# Apply most recent stash (keeps it in stash list)
git stash apply

# Apply and remove from stash list
git stash pop

# Apply a specific stash
git stash apply stash@{2}

# Create a branch from a stash
git stash branch new-branch-from-stash

# Apply a specific commit to current branch
git cherry-pick abc123

# Cherry-pick a range of commits
git cherry-pick abc123..def456

# Cherry-pick without committing (stage only)
git cherry-pick --no-commit abc123

# Use case: backport a fix to a release branch
git checkout release/1.0
git cherry-pick abc123  # the bugfix commit from main

# Start bisect
git bisect start

# Mark current commit as bad (has the bug)
git bisect bad

# Mark a known good commit (before the bug existed)
git bisect good v1.0.0

# Git checks out a midpoint commit. Test it, then:
git bisect good    # if this commit is fine
git bisect bad     # if this commit has the bug

# Repeat until Git identifies the exact bad commit
# Output: "abc123 is the first bad commit"

# Automated bisect with a test script
git bisect run npm test

# Reset when done
git bisect reset

# View reflog (recent HEAD movements)
git reflog
abc1234 HEAD@{0}: commit: Add new feature
def5678 HEAD@{1}: rebase: fast-forward
ghi9012 HEAD@{2}: checkout: moving from main to feature
jkl3456 HEAD@{3}: reset: moving to HEAD~3

# Recover a "lost" commit after a bad rebase/reset
git checkout -b recovery-branch HEAD@{3}

# Or reset current branch to a previous state
git reset --hard HEAD@{3}

# Create a worktree for a different branch (no stash needed!)
git worktree add ../project-hotfix hotfix/urgent-fix

# Work on the hotfix in ../project-hotfix
# while your main work stays untouched in the original directory

# List worktrees
git worktree list

# Remove when done
git worktree remove ../project-hotfix

# Format: type(scope): description

feat(auth): add OAuth2 login with Google provider
fix(api): handle null response from payment gateway
docs(readme): update installation instructions for v2
refactor(database): replace raw SQL with query builder
test(cart): add integration tests for checkout flow
chore(deps): update React from 19.0 to 19.1
perf(images): add lazy loading to product gallery

# Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore

# Branch protection rules (configure in GitHub/GitLab settings):
# - Require pull request reviews (1-2 approvals)
# - Require status checks to pass (CI/CD must be green)
# - Require branches to be up to date before merging
# - Require signed commits (optional, for high-security projects)
# - Restrict force push to main

# Using GitHub CLI to set up branch protection:
gh api repos/{owner}/{repo}/branches/main/protection \
  --method PUT \
  -f "required_pull_request_reviews[required_approving_review_count]=1" \
  -F "enforce_admins=true"

# Squash merge: combine all feature commits into one clean commit
git merge --squash feature/my-feature
git commit -m "feat(auth): add OAuth2 login with Google"

# Interactive rebase before PR to clean up messy commits
git rebase -i HEAD~5
# squash "wip" and "fix typo" commits into meaningful ones

# Amend the last commit message
git commit --amend -m "Better commit message"

# Add forgotten file to last commit
git add forgotten-file.js
git commit --amend --no-edit

# Install delta (beautiful diffs)
brew install git-delta
git config --global core.pager delta

# Install lazygit (terminal UI)
brew install lazygit

# Install GitHub CLI
brew install gh
gh auth login