Git Mastery: Advanced Workflows Every Developer Needs — From Junior to Senior

# Check the hash of file contents
echo "Hello, Git!" | git hash-object --stdin
# Result: e.g. af5626b4a114abcb82d63db7c8082c3c4756e51b

# Verify the object type
git cat-file -t af5626b
# Result: blob

# View the content
git cat-file -p af5626b
# Result: Hello, Git!

# Inspect the tree of the latest commit
git cat-file -p HEAD^{tree}
# 100644 blob a906cb2a4a904a15...    README.md
# 040000 tree 99f1a6d12cb4b6f1...    src
# 100644 blob 47c6340d6459e058...    package.json

# Inspect a commit's internals
git cat-file -p HEAD
# tree 99f1a6d12cb4b6f19c8655fca46c3ecf317074e0
# parent 8bd3ad5e1234567890abcdef1234567890abcdef
# author John Doe <john@example.com> 1711100000 +0900
# committer John Doe <john@example.com> 1711100000 +0900
#
# feat: add user authentication

# Create an annotated tag
git tag -a v1.0.0 -m "Release version 1.0.0"

# Inspect the tag object
git cat-file -p v1.0.0

# Same content = same hash
echo "same content" | git hash-object --stdin
echo "same content" | git hash-object --stdin
# Both results are identical

    A---B---C---D  (main)
         \
          E---F---G  (feature)
               \
                H---I  (hotfix)

# View the log as a graph
git log --oneline --graph --all --decorate

# Cleaner output
git log --oneline --graph --all --format="%h %s (%ar)"

.git/
  HEAD          # Pointer to the current branch
  config        # Repository-specific settings
  refs/
    heads/      # Local branches (each file = a commit hash)
    tags/       # Tags
    remotes/    # Remote branch tracking
  objects/      # All Git objects (blob, tree, commit, tag)
    pack/       # Compressed object pack files
  hooks/        # Git hook scripts
  index         # Staging area (binary)

# Check what HEAD points to
cat .git/HEAD
# ref: refs/heads/main

# See the commit that main points to
cat .git/refs/heads/main
# a1b2c3d4e5f6...

# Check object store size
git count-objects -vH

main ─────────────────────────────── (production)
  │
  └── develop ────────────────────── (development integration)
        │        │
        │   feature/login ────────── (feature development)
        │
        └── release/1.0 ──────────── (release preparation)
              │
              └── hotfix/bug-123 ──── (emergency fix)

# Initialize Git Flow (git-flow extension)
git flow init

# Start feature development
git flow feature start user-auth

# Complete feature development
git flow feature finish user-auth

main ────────────────────────────────
  │              │
  └── feature ───┘ (PR + merge)

# 1. Create a branch
git checkout -b feature/add-search

# 2. Work and commit
git add .
git commit -m "feat: add search functionality"

# 3. Push
git push -u origin feature/add-search

# 4. Create PR (GitHub CLI)
gh pr create --title "Add search functionality" --body "..."

# 5. Merge after review
gh pr merge --squash

main ──A──B──C──D──E──F──G──H──I──
            \─/     \─/
         (1-2 days)(1-2 days)

# Feature development
feature/JIRA-123-add-login
feature/user-profile-page

# Bug fixes
bugfix/JIRA-456-fix-null-pointer
fix/login-redirect-loop

# Hotfixes
hotfix/security-patch-xss
hotfix/v1.2.1

# Releases
release/1.0.0
release/2026-q1

# Experimental / maintenance
experiment/new-search-algo
chore/update-dependencies

git checkout main
git merge feature/login
# A merge commit is created

    A---B---C---D---M  (main, merge commit M)
         \         /
          E---F---G  (feature)

git checkout feature/login
git rebase main
# Feature commits are replayed on top of main

    A---B---C---D  (main)
                 \
                  E'---F'---G'  (feature, replayed)

# Interactively edit the last 5 commits
git rebase -i HEAD~5

pick a1b2c3d feat: add user model
pick d4e5f6g fix: typo in user model
pick h7i8j9k feat: add user controller
pick l0m1n2o WIP: debugging
pick p3q4r5s feat: add user routes

pick a1b2c3d feat: add user model
fixup d4e5f6g fix: typo in user model
pick h7i8j9k feat: add user controller
drop l0m1n2o WIP: debugging
pick p3q4r5s feat: add user routes

# Original commit
git commit -m "feat: add user model"

# Later, when a fix is needed
git commit --fixup HEAD
# Or target a specific commit
git commit --fixup a1b2c3d

# Automatic cleanup
git rebase -i --autosquash main

# Safe rebase (personal feature branch)
git checkout feature/my-task
git rebase main

# Dangerous rebase (never do this!)
git checkout main
git rebase feature/something  # Forbidden!

# Fix the most recent commit message (not yet pushed)
git commit --amend -m "feat: add user authentication"

# Open editor to edit message
git commit --amend

# Situation: committed to feature branch instead of main
# Method 1: cherry-pick
git checkout main
git cherry-pick abc1234
git checkout feature/wrong-branch
git reset --hard HEAD~1

# Method 2: stash
git reset --soft HEAD~1
git stash
git checkout correct-branch
git stash pop
git commit -m "correct commit message"

# Safe method: revert (creates a new commit, preserves history)
git revert abc1234
git push

# Dangerous method: reset + force push (rewrites history)
git reset --hard HEAD~1
git push --force-with-lease
# force-with-lease protects against overwriting others' commits

# When a conflict occurs
git merge feature/login
# CONFLICT (content): Merge conflict in src/auth.js

# Check conflicted files
git status

# Conflict marker structure
# <<<<<<< HEAD
# Code from current branch
# =======
# Code from the merging branch
# >>>>>>> feature/login

# After manual resolution
git add src/auth.js
git commit -m "resolve merge conflict in auth module"

# 1. Sync with main frequently
git fetch origin
git rebase origin/main

# 2. Commit and merge in small increments
# 3. Establish clear file ownership (CODEOWNERS)
# 4. Configure merge tools
git config --global merge.tool vimdiff
git mergetool

# Start bisect
git bisect start

# Mark current state as bad (has bug)
git bisect bad

# Mark a known good commit
git bisect good v1.0.0

# Git checks out a middle commit — test and decide
git bisect good  # or git bisect bad

# Repeat until the exact bad commit is found
# Result: abc1234 is the first bad commit

# End bisect
git bisect reset

# Test script failure = bad, success = good
git bisect start HEAD v1.0.0
git bisect run npm test
# Automatically finds the bug-introducing commit!

# Method 1: git-filter-repo (recommended)
pip install git-filter-repo
git filter-repo --path large-file.zip --invert-paths

# Method 2: BFG Repo-Cleaner
java -jar bfg.jar --delete-files large-file.zip
git reflog expire --expire=now --all
git gc --prune=now --aggressive

# Prevention: .gitignore
echo "*.zip" >> .gitignore
echo "*.tar.gz" >> .gitignore
echo "node_modules/" >> .gitignore

# Selectively stage changes by hunk
git add -p src/utils.js

# For each hunk:
# y - stage this hunk
# n - skip this hunk
# s - split into smaller hunks
# e - manually edit
# q - quit

# Method 1: stash
git stash push -m "WIP: feature work"
git checkout main
git checkout -b hotfix/critical-bug
# Work on the hotfix...
git checkout feature/my-work
git stash pop

# Method 2: worktree (the better approach!)
git worktree add ../hotfix-workspace main
cd ../hotfix-workspace
git checkout -b hotfix/critical-bug
# Work on the hotfix...
cd ../main-workspace
git worktree remove ../hotfix-workspace

# Method 1: interactive rebase
git rebase -i HEAD~4
# Change first to pick, rest to squash

# Method 2: soft reset
git reset --soft HEAD~4
git commit -m "feat: complete user authentication"

# Method 3: merge --squash
git checkout main
git merge --squash feature/user-auth
git commit -m "feat: add user authentication system"

# Add a submodule
git submodule add https://github.com/org/shared-lib.git libs/shared

# Clone with submodules
git clone --recurse-submodules https://github.com/org/project.git

# Update submodules
git submodule update --remote --merge

# Run command across all submodules
git submodule foreach 'git checkout main && git pull'

# Find the last commit of the deleted branch in reflog
git reflog
# abc1234 HEAD@{5}: checkout: moving from deleted-branch to main

# Recover the branch
git checkout -b recovered-branch abc1234

# Get a specific file from the main branch
git checkout main -- src/config.js

# Get a file from a specific commit
git checkout abc1234 -- src/config.js

# Change the last commit date to now
GIT_COMMITTER_DATE="$(date)" git commit --amend --date="$(date)"

# Set a specific date (during rebase)
GIT_COMMITTER_DATE="2026-03-22T10:00:00" git commit --amend --date="2026-03-22T10:00:00"

# See who last modified each line
git blame src/auth.js

# Check a specific line range
git blame -L 10,20 src/auth.js

# Ignore whitespace changes
git blame -w src/auth.js

# Track code movement
git blame -M src/auth.js
git blame -C src/auth.js

# File change history (follows renames)
git log --follow -p -- src/auth.js

# Find commits that added/removed a specific string (pickaxe)
git log -S "API_KEY" --oneline

# Filter by author
git log --author="John" --oneline --since="2026-01-01"

# Include statistics
git log --stat --oneline -10

# Diff between commits
git log -p --oneline -3

# Add multiple remotes
git remote add upstream https://github.com/original/repo.git
git remote add deploy git@deploy-server:app.git

# Sync with upstream (forked project)
git fetch upstream
git rebase upstream/main

# Clean up remote branches
git remote prune origin
git fetch --prune

# Create an annotated tag
git tag -a v2.0.0 -m "Release 2.0.0: new payment system"

# Tag a specific commit
git tag -a v1.5.0 abc1234 -m "Hotfix release"

# Push tags
git push origin v2.0.0
git push origin --tags

# Delete a tag
git tag -d v2.0.0-beta
git push origin --delete v2.0.0-beta

# .husky/pre-commit
#!/bin/sh
npx lint-staged

# .husky/commit-msg
#!/bin/sh
npx commitlint --edit "$1"

# .husky/pre-push
#!/bin/sh
npm test

# Create a patch
git diff > my-changes.patch
git format-patch -3  # Create patch files from the last 3 commits

# Apply a patch
git apply my-changes.patch
git am *.patch  # Apply patches created by format-patch

# View the reflog (HEAD movement history)
git reflog

# Recover after an accidental reset --hard
git reflog
# abc1234 HEAD@{2}: commit: important work
git reset --hard abc1234

# Recover an accidentally dropped stash
git fsck --unreachable | grep commit
git stash apply abc1234

type(scope): description

[optional body]

[optional footer(s)]

feat(api)!: change authentication endpoint

BREAKING CHANGE: /auth/login is now /api/v2/auth/login

# Install packages
npm install -D @commitlint/cli @commitlint/config-conventional husky

# Configure commitlint
echo "module.exports = { extends: ['@commitlint/config-conventional'] };" > commitlint.config.js

# Initialize Husky
npx husky init
echo 'npx commitlint --edit "$1"' > .husky/commit-msg

# Install conventional-changelog
npm install -D conventional-changelog-cli

# Generate CHANGELOG.md
npx conventional-changelog -p angular -i CHANGELOG.md -s

{
  "scripts": {
    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
    "release": "standard-version"
  }
}

npm install -D semantic-release

{
  "release": {
    "branches": ["main"],
    "plugins": [
      "@semantic-release/commit-analyzer",
      "@semantic-release/release-notes-generator",
      "@semantic-release/changelog",
      "@semantic-release/npm",
      "@semantic-release/github",
      "@semantic-release/git"
    ]
  }
}

name: CI Pipeline

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node-version: [18, 20, 22]

    steps:
      - uses: actions/checkout@v4

      - name: Use Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
          cache: 'npm'

      - run: npm ci
      - run: npm run lint
      - run: npm test
      - run: npm run build

name: PR Checks

on:
  pull_request:
    types: [opened, synchronize, reopened]

jobs:
  lint-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Node
        uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'npm'

      - run: npm ci

      - name: Lint
        run: npm run lint

      - name: Type Check
        run: npx tsc --noEmit

      - name: Unit Tests
        run: npm test -- --coverage

      - name: Build
        run: npm run build

      - name: Upload coverage
        uses: codecov/codecov-action@v4
        with:
          file: ./coverage/lcov.info

name: Auto Label

on:
  pull_request:
    types: [opened, edited]

jobs:
  label:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/labeler@v5
        with:
          repo-token: ${{ secrets.GITHUB_TOKEN }}

# .github/labeler.yml
frontend:
  - changed-files:
      - any-glob-to-any-file: 'src/components/**'

backend:
  - changed-files:
      - any-glob-to-any-file: 'src/api/**'

documentation:
  - changed-files:
      - any-glob-to-any-file: 'docs/**'

tests:
  - changed-files:
      - any-glob-to-any-file: '**/*.test.*'

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: 'npm'
    directory: '/'
    schedule:
      interval: 'weekly'
      day: 'monday'
    open-pull-requests-limit: 10
    labels:
      - 'dependencies'
    groups:
      dev-dependencies:
        dependency-type: 'development'
      production-dependencies:
        dependency-type: 'production'

  - package-ecosystem: 'github-actions'
    directory: '/'
    schedule:
      interval: 'weekly'

name: Deploy

on:
  push:
    tags:
      - 'v*'

jobs:
  deploy:
    runs-on: ubuntu-latest
    environment: production
    steps:
      - uses: actions/checkout@v4

      - name: Setup Node
        uses: actions/setup-node@v4
        with:
          node-version: 20

      - run: npm ci
      - run: npm run build

      - name: Deploy to Production
        run: |
          echo "Deploying version $GITHUB_REF_NAME"
          # Actual deployment commands here

# Initialize Nx
npx create-nx-workspace@latest my-workspace

# Initialize Turborepo
npx create-turbo@latest

# Example project structure
my-monorepo/
  apps/
    web/          # Next.js web app
    mobile/       # React Native app
    api/          # Express API server
  packages/
    ui/           # Shared UI components
    utils/        # Shared utilities
    config/       # Shared configuration
  turbo.json
  package.json

# .github/CODEOWNERS

# Default reviewers for the entire project
* @team-lead

# Frontend
/apps/web/        @frontend-team
/packages/ui/     @frontend-team

# Backend
/apps/api/        @backend-team
/packages/utils/  @backend-team

# DevOps
/.github/         @devops-team
/docker/          @devops-team
*.yml             @devops-team

{
  "pipeline": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**"]
    },
    "test": {
      "dependsOn": ["build"]
    },
    "lint": {}
  }
}

# Build only changed packages
npx turbo run build --filter=...[HEAD^1]

# Build a specific app
npx turbo run build --filter=web

# Build including dependencies
npx turbo run build --filter=web...

# Clone only the latest commit (useful for CI/CD)
git clone --depth 1 https://github.com/org/repo.git

# Fetch full history later if needed
git fetch --unshallow

# Clone without blobs (downloaded on demand)
git clone --filter=blob:none https://github.com/org/repo.git

# Exclude trees as well (fastest clone)
git clone --filter=tree:0 https://github.com/org/repo.git

# Enable sparse checkout
git sparse-checkout init --cone

# Checkout specific directories only
git sparse-checkout set apps/web packages/ui

# Add another directory
git sparse-checkout add apps/api

# Check current configuration
git sparse-checkout list

# Install and initialize Git LFS
git lfs install

# Track large files
git lfs track "*.psd"
git lfs track "*.zip"
git lfs track "assets/videos/*"

# Check .gitattributes
cat .gitattributes
# *.psd filter=lfs diff=lfs merge=lfs -text

# Check LFS status
git lfs ls-files
git lfs status

# Enable automatic maintenance
git maintenance start

# Manual garbage collection
git gc --aggressive

# Check object compression status
git count-objects -vH

# Clean up stale references
git remote prune origin
git reflog expire --expire=30.days

# Register with Scalar (included in Git 2.38+)
scalar register

# Or clone fresh
scalar clone https://github.com/org/massive-repo.git

# Scalar automatically configures:
# - Partial clone
# - Sparse checkout
# - Background maintenance
# - Filesystem monitor
# - Commit graph

# Auto-generate commit messages with Claude Code
claude commit

# GitHub Copilot CLI
gh copilot suggest "write a commit message for these changes"

# aicommits tool
npm install -g aicommits
aicommits

# Enable GitHub Copilot auto-review (in repository settings)
# Settings > Code review > Copilot code review > Enable

# Request a review of staged changes
claude "review my staged changes"

# Write a commit message
claude "write a conventional commit message for my changes"

# Generate a PR description
claude "write a PR description for the current branch"

# Resolve merge conflicts
claude "help me resolve the merge conflicts in src/auth.js"

name: Auto PR Description

on:
  pull_request:
    types: [opened]

jobs:
  describe:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Generate PR description
        uses: anthropics/claude-code-action@v1
        with:
          prompt: |
            Analyze the diff of this PR and generate a clear description
            including what changed, why, and any risks.