Last updated: April 5, 2026 | Reading time: 28 min
Git remains the undisputed version control system powering modern software development. With Git 2.56.0 confirmed as the latest stable release as of September 2026 – shipped by 104 contributors who logged 748 non-merge commits, including 39 first-time contributors, according to GitHub’s own release coverage – and Git 3.0 still on the horizon for late 2026, there has never been a better time to master Git from the ground up. This thorough git tutorial takes you from your first repository to advanced workflows used by professional engineering teams, complete with real-world code examples, troubleshooting guides, and production-ready configurations.
Whether you are a complete beginner writing your first commit or an intermediate developer looking to level up your branching strategy, this guide covers every essential Git concept with practical, hands-on exercises – echoing the same fundamentals that Coursera’s 2026 Git learning roadmap distills into five core practice steps for beginners, and reflecting just how much demand there is for this skill: Udemy alone listed 403 dedicated Git courses that had drawn 3,659,181 learners as of May 2025, per Udemy’s own course data. By the end, you will have a complete working project under version control and the confidence to use Git in any professional environment.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
Prerequisites and Environment Setup for This Git Tutorial
Before diving into this git tutorial, you need a properly configured development environment. Git runs on every major operating system, but the installation process and default settings vary significantly between platforms – Windows users, for instance, should grab Git for Windows 2.55.0, released in August 2026, to stay current with upstream Git. Getting the setup right from the start prevents hours of frustration later.
Here are the prerequisites you need to follow along with every example in this guide:
- Git 2.47 or later (2.52 recommended) – Earlier versions lack reftable support and geometric maintenance
- A terminal emulator – Terminal.app (macOS), Windows Terminal (Windows 11), or any Linux terminal
- A text editor – VS Code 1.96+, Neovim 0.10+, or any editor with Git integration
- A GitHub or GitLab account – Free tier is sufficient for all exercises
- SSH key pair – For secure authentication with remote repositories
- Node.js 22 LTS or Python 3.13+ – For the sample project (either language works)
- 8 GB RAM minimum – Required for comfortable operation with large repositories
Installing Git on Every Platform
Installation methods differ by operating system. Use the package manager native to your platform for the smoothest experience:
# macOS (Homebrew)
brew install git
# Ubuntu / Debian
sudo apt update && sudo apt install git -y
# Fedora / RHEL
sudo dnf install git -y
# Windows (winget)
winget install --id Git.Git -e --source winget
# Verify installation
git --version
# Expected output: git version 2.52.0 (or later)After installation, configure your identity. Git attaches your name and email to every commit, and these values are visible in the project history. Set them globally so they apply to all repositories on your machine:
# Set your identity
git config --global user.name "Your Name"
git config --global user.email "[email protected]"
# Set default branch name to main
git config --global init.defaultBranch main
# Enable helpful colorized output
git config --global color.ui auto
# Set VS Code as default editor (optional)
git config --global core.editor "code --wait"
# Verify your configuration
git config --list --globalWith Git 2.52, you can also enable the new reftable backend for new repositories. This replaces the legacy loose-reference storage with a binary format that eliminates filesystem race conditions and delivers significantly faster reads in repositories with thousands of branches:
# Enable reftable backend for new repos (Git 2.52+)
git config --global init.defaultObjectFormat sha256
git config --global init.defaultRefFormat reftableThe SHA-256 object format is now production-ready in Git 2.52 and will become the default in Git 3.0. Setting it now future-proofs your new repositories against the eventual SHA-1 deprecation that enterprise teams are already planning for.
Step 1: Creating Your First Git Repository
A Git repository is a directory that Git tracks for changes. Every file modification, addition, or deletion is recorded in the repository history, creating a complete timeline of your project. This is the foundation of every git tutorial: understanding how repositories work – it’s no accident that Coursera’s 2026 Git learning roadmap opens its own beginner path with this exact same git init command, per its March 2026 lesson update.
Create a new project directory and initialize it as a Git repository:
# Create project directory
mkdir git-tutorial-project && cd git-tutorial-project
# Initialize a new Git repository
git init
# Expected output:
# Initialized empty Git repository in /home/user/git-tutorial-project/.git/
# Check repository status
git status
# Expected output:
# On branch main
# No commits yet
# nothing to commit (create/copy files and use "git add" to track)The git init command creates a hidden .git directory containing the entire repository database. This directory stores objects (your file snapshots), references (branch pointers), configuration, and hooks. Never manually edit files inside .git unless you fully understand the internal data model.
Now create the initial project files. We will build a simple task manager application throughout this tutorial:
# Create project structure
mkdir src tests docs
touch src/app.js src/utils.js tests/app.test.js README.md .gitignore
# Add content to .gitignore
cat > .gitignore << 'EOF'
node_modules/
dist/
.env
.env.local
*.log
.DS_Store
coverage/
EOF
# Add initial application code
cat > src/app.js << 'EOF'
const { generateId } = require('./utils');
class TaskManager {
constructor() {
this.tasks = [];
}
addTask(title, priority = 'medium') {
const task = {
id: generateId(),
title,
priority,
completed: false,
createdAt: new Date().toISOString()
};
this.tasks.push(task);
return task;
}
completeTask(id) {
const task = this.tasks.find(t => t.id === id);
if (!task) throw new Error(`Task ${id} not found`);
task.completed = true;
task.completedAt = new Date().toISOString();
return task;
}
listTasks(filter = 'all') {
if (filter === 'completed') return this.tasks.filter(t => t.completed);
if (filter === 'pending') return this.tasks.filter(t => !t.completed);
return [...this.tasks];
}
}
module.exports = { TaskManager };
EOF
# Add utility module
cat > src/utils.js << 'EOF'
function generateId() {
return Math.random().toString(36).substring(2, 10);
}
function formatDate(isoString) {
return new Date(isoString).toLocaleDateString('en-US', {
year: 'numeric',
month: 'short',
day: 'numeric'
});
}
module.exports = { generateId, formatDate };
EOFWith the project files in place, you have an untracked working directory. Git knows the repository exists but is not yet tracking any files. The next step teaches you how to stage and commit these files into the repository history.
Step 2: Understanding the Git Staging Area and Commits
Git uses a three-stage architecture that separates your working directory, the staging area (also called the index), and the committed history. Understanding this model is critical – it is the single concept that trips up more beginners than any other in every git tutorial.
The workflow follows this pattern: you modify files in your working directory, stage selected changes with git add, and then permanently record the staged snapshot with git commit. This two-step process gives you fine-grained control over exactly what goes into each commit.
# Check which files are untracked
git status
# Output shows all files in red (untracked)
# Stage specific files
git add src/app.js src/utils.js
# Check status again — staged files appear in green
git status
# Stage remaining files
git add .gitignore README.md tests/
# Create your first commit
git commit -m "feat: initialize task manager project with core modules"
# Expected output:
# [main (root-commit) a1b2c3d] feat: initialize task manager project with core modules
# 5 files changed, 52 insertions(+)
# create mode 100644 .gitignore
# create mode 100644 README.md
# create mode 100644 src/app.js
# create mode 100644 src/utils.js
# create mode 100644 tests/app.test.js
# View commit history
git log --oneline
# a1b2c3d (HEAD -> main) feat: initialize task manager project with core modulesEvery commit in Git is identified by a unique SHA hash (40 hexadecimal characters, or 64 with SHA-256). Each commit contains a snapshot of all tracked files, the author information, a timestamp, a commit message, and a pointer to the parent commit. This chain of parent pointers forms the complete project history.
Use the git diff command to inspect changes before staging them. This is an essential habit that prevents accidentally committing unintended changes:
# See unstaged changes (working directory vs staging area)
git diff
# See staged changes (staging area vs last commit)
git diff --staged
# See changes in a specific file
git diff src/app.js
# See a summary of changes (files changed, insertions, deletions)
git diff --statStep 3: Branching and Merging – The Core of Git Workflows
Branches are lightweight, movable pointers to commits. They allow you to develop features, fix bugs, and experiment in isolation without affecting the main codebase. Branching is what makes Git fundamentally different from older version control systems, and it is the feature that enables modern collaborative workflows.
In Git, creating a branch is nearly instantaneous because it only creates a 41-byte file (or a small binary entry with reftable). There is zero overhead to having hundreds of branches, which is why professional teams create a new branch for every feature, bugfix, or experiment.
# Create and switch to a new branch
git checkout -b feature/add-delete-task
# Modern alternative (Git 2.23+)
git switch -c feature/add-delete-task
# List all branches (* marks current branch)
git branch
# * feature/add-delete-task
# main
# Add the delete feature to src/app.js
cat >> src/app.js << 'EOF'
// Delete a task by ID
TaskManager.prototype.deleteTask = function(id) {
const index = this.tasks.findIndex(t => t.id === id);
if (index === -1) throw new Error(`Task ${id} not found`);
return this.tasks.splice(index, 1)[0];
};
EOF
# Stage and commit the change
git add src/app.js
git commit -m "feat: add deleteTask method to TaskManager"
# Switch back to main
git switch main
# Merge the feature branch into main
git merge feature/add-delete-task
# Expected output:
# Updating a1b2c3d..e4f5g6h
# Fast-forward
# src/app.js | 7 +++++++
# 1 file changed, 7 insertions(+)
# Delete the merged branch (cleanup)
git branch -d feature/add-delete-taskThe merge above was a fast-forward merge because main had no new commits since the branch was created. Git simply moved the main pointer forward. When both branches have diverged with independent commits, Git performs a three-way merge that creates a new merge commit combining both histories.
Understanding the difference between merge strategies is essential for any team workflow. Here is a comparison of the most common approaches used in 2026:
| Merge Strategy | History Shape | Best For | Command | Preserves Context |
|---|---|---|---|---|
| Fast-Forward | Linear | Simple feature branches | git merge --ff-only | No merge commit |
| Three-Way Merge | Branched | Long-lived feature branches | git merge --no-ff | Yes, merge commit |
| Squash Merge | Linear | Cleaning up messy history | git merge --squash | Collapses to single commit |
| Rebase | Linear | Keeping clean history | git rebase main | Rewrites commit hashes |
| Octopus Merge | Multi-parent | Merging 3+ branches at once | git merge b1 b2 b3 | Yes, multi-parent commit |
Step 4: Working with Remote Repositories
Local Git repositories are powerful, but collaboration requires a remote repository hosted on a platform like GitHub, GitLab, or Bitbucket – GitLab alone posted $955.2 million in FY2026 revenue and crossed the $1 billion annual recurring revenue mark by March 2026, according to GitLab Inc., a reminder of just how much of modern software collaboration now runs through these hosted platforms. Remote repositories serve as the central synchronization point where team members push their changes and pull updates from others.
First, set up SSH authentication for secure, password-less access to your remote:
# Generate an SSH key pair (Ed25519 is the recommended algorithm in 2026)
ssh-keygen -t ed25519 -C "[email protected]"
# Start the SSH agent
eval "$(ssh-agent -s)"
# Add your key to the agent
ssh-add ~/.ssh/id_ed25519
# Copy the public key (paste into GitHub/GitLab settings)
cat ~/.ssh/id_ed25519.pub
# Test the connection
ssh -T [email protected]
# Hi username! You've successfully authenticatedWith authentication configured, connect your local repository to a remote and push your code:
# Add a remote repository (create the repo on GitHub first)
git remote add origin [email protected]:username/git-tutorial-project.git
# Verify the remote
git remote -v
# origin [email protected]:username/git-tutorial-project.git (fetch)
# origin [email protected]:username/git-tutorial-project.git (push)
# Push main branch and set upstream tracking
git push -u origin main
# Expected output:
# Enumerating objects: 10, done.
# Counting objects: 100% (10/10), done.
# Writing objects: 100% (10/10), 1.24 KiB | 1.24 MiB/s, done.
# Total 10 (delta 0), reused 0 (delta 0)
# To github.com:username/git-tutorial-project.git
# * [new branch] main -> main
# Branch 'main' set up to track remote branch 'main' from 'origin'.
# Pull changes from remote
git pull origin main
# Fetch without merging (inspect before integrating)
git fetch originThe distinction between git fetch and git pull is important. git fetch downloads new data from the remote without modifying your working directory or current branch. git pull is essentially git fetch followed by git merge. For safer workflows, many experienced developers prefer to fetch first, review the incoming changes, and then merge manually.
Step 5: Resolving Merge Conflicts Like a Professional
Merge conflicts occur when two branches modify the same lines of the same file. Git cannot automatically determine which version to keep, so it marks the conflicting sections and asks you to resolve them manually. Conflict resolution is an unavoidable skill in any collaborative git tutorial – every developer encounters conflicts regularly.
Let us create a deliberate conflict to practice resolution:
# Create two branches that modify the same file
git switch -c feature/priority-colors
# Edit src/utils.js to add a color function
cat >> src/utils.js << 'EOF'
function getPriorityColor(priority) {
const colors = { high: 'red', medium: 'yellow', low: 'green' };
return colors[priority] || 'gray';
}
module.exports = { generateId, formatDate, getPriorityColor };
EOF
git add src/utils.js
git commit -m "feat: add priority color mapping"
# Switch back and create a conflicting branch
git switch main
git switch -c feature/priority-icons
# Edit src/utils.js with a different addition
cat >> src/utils.js << 'EOF'
function getPriorityIcon(priority) {
const icons = { high: '🔴', medium: '🟡', low: '🟢' };
return icons[priority] || '⚪';
}
module.exports = { generateId, formatDate, getPriorityIcon };
EOF
git add src/utils.js
git commit -m "feat: add priority icon mapping"
# Merge priority-colors into main first
git switch main
git merge feature/priority-colors
# Fast-forward merge succeeds
# Now merge priority-icons — this will conflict
git merge feature/priority-icons
# CONFLICT (content): Merge conflict in src/utils.js
# Automatic merge failed; fix conflicts and then commit the result.When a conflict occurs, Git marks the affected sections in the file with conflict markers. Open the conflicting file and you will see:
// In src/utils.js — the conflict markers look like this:
<<<<<<< HEAD
function getPriorityColor(priority) {
const colors = { high: 'red', medium: 'yellow', low: 'green' };
return colors[priority] || 'gray';
}
module.exports = { generateId, formatDate, getPriorityColor };
=======
function getPriorityIcon(priority) {
const icons = { high: '🔴', medium: '🟡', low: '🟢' };
return icons[priority] || '⚪';
}
module.exports = { generateId, formatDate, getPriorityIcon };
>>>>>>> feature/priority-icons
// RESOLUTION: Keep both functions and update the exports
function getPriorityColor(priority) {
const colors = { high: 'red', medium: 'yellow', low: 'green' };
return colors[priority] || 'gray';
}
function getPriorityIcon(priority) {
const icons = { high: '🔴', medium: '🟡', low: '🟢' };
return icons[priority] || '⚪';
}
module.exports = { generateId, formatDate, getPriorityColor, getPriorityIcon };After resolving the conflict by editing the file, remove the conflict markers (<<<<<<<, =======, >>>>>>>), stage the resolved file – as of Git 2.56.0 (September 2026) you can do this explicitly with the new git add --resolved flag, per GitHub's release notes – and create the merge commit:
# After editing the file to resolve conflicts
git add src/utils.js
git commit -m "merge: combine priority colors and icons"
# Verify the merge succeeded
git log --oneline --graph
# * f1g2h3i (HEAD -> main) merge: combine priority colors and icons
# |
# | * d4e5f6g (feature/priority-icons) feat: add priority icon mapping
# * | b7c8d9e (feature/priority-colors) feat: add priority color mapping
# |/
# * a1b2c3d feat: initialize task manager projectStep 6: Git Log, Blame, and History Investigation
Git's history investigation tools are among its most powerful features. Professional developers spend significant time reading history to understand why code exists, who introduced a change, and when bugs were introduced. Mastering these commands transforms Git from a simple backup tool into a forensic investigation platform.
# Compact history view
git log --oneline --graph --all
# Detailed log with diffs
git log -p -2 # Show patches for the last 2 commits
# Search commits by message
git log --grep="feat:" --oneline
# Search commits by content changes (pickaxe search)
git log -S "deleteTask" --oneline
# Show who changed each line of a file
git blame src/app.js
# Show changes introduced by a specific commit
git show a1b2c3d
# Log with date range
git log --after="2026-01-01" --before="2026-04-01" --oneline
# Beautiful formatted log
git log --pretty=format:"%C(yellow)%h%C(reset) - %C(green)%an%C(reset) - %s (%C(blue)%ar%C(reset))"The git bisect command is particularly powerful for finding the exact commit that introduced a bug. It uses a binary search algorithm to efficiently narrow down the problematic commit, even across thousands of commits, and as of Git 2.56.0 (released September 2026) a new git bisect --reset-when-found flag automatically resets the bisect session the moment the culprit commit is identified, as TuxMachines noted in its coverage of the release:
# Start bisecting
git bisect start
# Mark the current commit as bad (contains the bug)
git bisect bad
# Mark a known good commit
git bisect good a1b2c3d
# Git checks out a middle commit — test it and mark accordingly
git bisect good # or: git bisect bad
# Repeat until Git identifies the exact commit
# Bisecting: 0 revisions left to test after this
# abc1234 is the first bad commit
# Reset when done
git bisect resetGit 2.52 introduced the git last-modified command which significantly outperforms the traditional git log -1 --format="%ai" -- filename approach for retrieving the last modification date of files. In benchmarks on large monorepos, this new command runs up to 30 times faster than the equivalent log query.
Step 7: Stashing, Rebasing, and Cherry-Picking
These three commands handle common workflow interruptions that every developer faces. Stashing saves work-in-progress without committing. Rebasing rewrites history for cleaner linear logs. Cherry-picking applies specific commits from one branch to another. Together, they form the toolkit for managing complex, real-world development scenarios.
Git Stash temporarily shelves your uncommitted changes so you can switch branches without losing work:
# Save uncommitted changes to the stash
git stash push -m "WIP: adding search feature"
# List all stashed changes
git stash list
# stash@{0}: On main: WIP: adding search feature
# Apply the most recent stash (keeps it in the 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 feature/search stash@{0}
# Drop a specific stash
git stash drop stash@{0}
# Clear all stashes
git stash clearGit Rebase moves or replays commits onto a different base. The primary use case is keeping a feature branch up-to-date with main without creating merge commits:
# Update feature branch with latest main changes
git switch feature/search
git rebase main
# If conflicts occur during rebase
git rebase --continue # after resolving conflicts
git rebase --abort # to cancel the rebase entirely
git rebase --skip # to skip the current commit
# Interactive rebase to clean up the last 3 commits
git rebase -i HEAD~3
# Opens editor with options: pick, reword, edit, squash, fixup, dropCherry-Pick applies a specific commit from any branch to your current branch. This is useful when you need a particular fix without merging an entire branch:
# Apply a specific commit to the current branch
git cherry-pick abc1234
# Cherry-pick without committing (stage changes only)
git cherry-pick --no-commit abc1234
# Cherry-pick a range of commits
git cherry-pick abc1234..def5678A critical rule for rebasing: never rebase commits that have been pushed to a shared remote branch. Rebasing rewrites commit hashes, which causes divergent histories for anyone who has already pulled the original commits. This is the golden rule of Git that protects your team from painful merge situations.
Step 8: Git Hooks and Automation
Git hooks are scripts that run automatically at specific points in the Git workflow. They enable powerful automation: running tests before commits, enforcing commit message formats, preventing pushes to protected branches, and triggering deployment pipelines. Hooks are stored in the .git/hooks directory and execute locally on each developer's machine.
The most commonly used hooks in professional development teams are:
| Hook Name | Trigger Point | Common Use Case | Blocks Operation | Shareable via Repo |
|---|---|---|---|---|
| pre-commit | Before commit is created | Linting, formatting, type checking | Yes (non-zero exit) | Yes, with Husky/lefthook |
| commit-msg | After message is entered | Enforce conventional commits format | Yes (non-zero exit) | Yes, with Husky/lefthook |
| pre-push | Before push to remote | Run test suite, check coverage | Yes (non-zero exit) | Yes, with Husky/lefthook |
| post-merge | After successful merge | Install dependencies, rebuild | No | Yes, with Husky/lefthook |
| pre-rebase | Before rebase starts | Prevent rebase on protected branches | Yes (non-zero exit) | Yes, with Husky/lefthook |
| post-checkout | After branch switch | Auto-install, environment setup | No | Yes, with Husky/lefthook |
Here is a practical pre-commit hook that enforces code quality before allowing a commit:
#!/bin/sh
# .git/hooks/pre-commit — runs before every commit
# Run linter on staged files only
STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep '.js$')
if [ -n "$STAGED_FILES" ]; then
echo "Running ESLint on staged files..."
npx eslint $STAGED_FILES --max-warnings=0
if [ $? -ne 0 ]; then
echo "❌ ESLint found errors. Fix them before committing."
exit 1
fi
fi
# Check for accidental secret commits
if git diff --cached --name-only | grep -qE '.(env|pem|key)$'; then
echo "❌ Detected sensitive files staged for commit. Remove them."
exit 1
fi
echo "✅ Pre-commit checks passed."
exit 0For team projects, use Husky (v9+) or lefthook to share Git hooks through the repository. These tools install hooks automatically when a teammate runs npm install:
# Install Husky
npm install --save-dev husky
npx husky init
# The init command creates .husky/ directory and a pre-commit hook
# Edit .husky/pre-commit:
echo "npx lint-staged" > .husky/pre-commit
# Install lint-staged for running linters on staged files only
npm install --save-dev lint-staged
# Add lint-staged config to package.json
# "lint-staged": {
# "*.js": ["eslint --fix", "prettier --write"],
# "*.{json,md}": ["prettier --write"]
# }Step 9: Advanced Git Workflows for Teams
Professional engineering teams follow structured branching strategies to coordinate work across multiple developers, environments, and release cycles. The choice of workflow affects merge frequency, release cadence, and code review practices. In 2026, the industry has largely converged on two dominant patterns, with a third gaining traction for monorepo setups – unsurprising given that Git now commands 85.22% of the source code management market, according to a 2026 FossPost roundup, with hosting platforms scaling to match: GitLab alone grew to more than 50 million registered users by March 2026, up from roughly 30 million just a year earlier, per GitLab Inc.
GitHub Flow is the simplest strategy and works well for teams practicing continuous deployment. Every change starts on a feature branch, goes through a pull request with code review, and merges directly to main. The main branch is always deployable.
# GitHub Flow workflow
git switch -c feature/TICKET-123-user-search
# ... make changes, commit regularly ...
git push -u origin feature/TICKET-123-user-search
# Open a Pull Request on GitHub
# After review and CI passes:
# Merge via GitHub UI (squash merge recommended)
# Delete the remote branch after mergeTrunk-Based Development takes this further by requiring developers to merge to main at least once per day. Feature flags replace long-lived branches, and the main branch is always in a releasable state. This approach is used by Google, Meta, and most high-performing engineering organizations according to the 2025 DORA State of DevOps report.
Git Worktrees allow you to check out multiple branches simultaneously in separate directories without cloning the repository again. This is invaluable when you need to work on a hotfix while your feature branch has uncommitted changes:
# Create a worktree for a hotfix branch
git worktree add ../hotfix-branch hotfix/critical-bug
# List all worktrees
git worktree list
# /home/user/git-tutorial-project a1b2c3d [main]
# /home/user/hotfix-branch e4f5g6h [hotfix/critical-bug]
# Work in the hotfix directory
cd ../hotfix-branch
# ... fix the bug, commit, push ...
# Remove the worktree when done
git worktree remove ../hotfix-branchGit 2.52 improves worktree stability with the reftable backend by eliminating race conditions that could occur when two worktrees modified references simultaneously. If you work with multiple worktrees regularly, enabling reftable is strongly recommended.
Step 10: Git Performance Optimization for Large Repositories
As repositories grow to contain thousands of files and hundreds of thousands of commits, Git operations can slow down significantly. Git 2.52 introduces several performance features specifically designed for large-scale repositories, building on the Scalar project that Microsoft developed for the Windows OS repository (the largest Git repository in the world at 300+ GB).
The geometric maintenance strategy introduced in Git 2.52 replaces the traditional all-into-one repacking approach, and later releases have sharpened it further – LinuxCompatible reported that Git 2.56.0 (September 2026) cut one monorepo's merge-base traversal time from 0.68 seconds down to just 0.01 seconds, while a path-walk repack on that same release came out roughly 71% smaller. Instead of periodically repacking all objects into a single pack file (which can take hours on large repositories), geometric maintenance maintains a series of geometrically-sized pack files that are incrementally compacted:
# Enable background maintenance (runs hourly by default)
git maintenance start
# Configure geometric repacking (Git 2.52+)
git config maintenance.strategy geometric
# Run maintenance manually
git maintenance run --task=gc
git maintenance run --task=commit-graph
git maintenance run --task=prefetch
# Enable sparse checkout for large monorepos
git sparse-checkout init --cone
git sparse-checkout set src/ tests/ docs/
# Verify sparse checkout configuration
git sparse-checkout list
# Enable the commit-graph for faster log operations
git commit-graph write --reachable --changed-paths
# Partial clone — download only what you need
git clone --filter=blob:none [email protected]:org/large-repo.git
git clone --filter=tree:0 [email protected]:org/large-repo.git # Treeless cloneHere is a comparison of Git performance optimization techniques and their impact:
| Optimization | Best For | Speed Improvement | Minimum Git Version | Trade-offs |
|---|---|---|---|---|
| Commit Graph | git log, git merge-base | 10-100x faster traversal | 2.18+ | Small disk overhead (~50MB) |
| Sparse Checkout | Large monorepos | 80-95% fewer files on disk | 2.25+ | Some commands need full checkout |
| Partial Clone | Huge repositories | 90%+ faster initial clone | 2.22+ | Network required for blob access |
| Geometric Repacking | Repos with frequent pushes | 5-20x faster maintenance | 2.52+ | Slightly more disk than single pack |
| Reftable Backend | Repos with many branches/tags | 2-20x faster ref operations | 2.48+ | Not backward-compatible with loose refs |
| Sparse Index | Monorepos with sparse checkout | 2-10x faster status/add | 2.32+ | Some extensions may not support it |
Common Pitfalls Every Git User Must Avoid
Even experienced developers fall into these traps. Being aware of these common pitfalls will save you hours of debugging and prevent potentially catastrophic data loss in your repositories. This section of the git tutorial focuses on the mistakes that cause the most real-world damage.
Pitfall 1: Committing sensitive data. Once a secret (API key, password, private key) is committed to Git, it exists in the repository history forever – even if you delete the file in a subsequent commit. Anyone with access to the repo can find it with git log -p. Always use .gitignore to exclude .env files, and use tools like git-secrets or gitleaks to scan for accidental secret commits before pushing.
Pitfall 2: Using git push --force on shared branches. Force-pushing rewrites remote history, which destroys any commits that other team members have pushed since your last pull. If you must force-push, use git push --force-with-lease instead – it fails if the remote has commits you have not fetched, preventing accidental overwrites.
Pitfall 3: Not pulling before pushing. Pushing without first pulling the latest changes from the remote causes rejected pushes and unnecessary merge conflicts. Make it a habit to git pull --rebase before pushing to keep your history clean and avoid surprises.
Pitfall 4: Enormous commits with vague messages. Committing 50 files with the message "updates" makes the repository history useless for debugging. Follow the conventional commits specification (feat:, fix:, chore:, docs:) and keep each commit focused on a single logical change. A good commit message explains why the change was made, not just what changed.
Pitfall 5: Committing generated files and dependencies. Never commit node_modules/, dist/, __pycache__/, or build artifacts. These bloat the repository size permanently (Git never truly deletes data from history) and cause constant merge conflicts. Use .gitignore from project initialization.
Pitfall 6: Working directly on the main branch. Making changes directly on main bypasses code review, prevents CI/CD from running pre-merge checks, and makes it impossible to revert a feature without reverting unrelated changes. Always create a feature branch, even for small fixes.
Pitfall 7: Ignoring merge conflicts by accepting one side entirely. When resolving conflicts, blindly accepting "ours" or "theirs" without reading both versions often silently discards important changes. Always read and understand both sides of a conflict before resolving it.
Troubleshooting Guide: Fixing the Most Common Git Problems
Every developer eventually encounters Git errors that seem impossible to fix. This troubleshooting section covers the most frequently searched Git problems with tested solutions that work in Git 2.52. Bookmark this section – you will need it.
Problem 1: "fatal: not a git repository"
This error means you are running a Git command outside of a repository directory. Navigate to your project root with cd /path/to/project and verify the .git directory exists with ls -la .git. If the .git folder was accidentally deleted, you need to reinitialize with git init and re-add the remote.
Problem 2: "error: failed to push some refs"
The remote branch has commits that your local branch does not. Pull first, then push:
# Option A: Pull with rebase (cleaner history)
git pull --rebase origin main
git push origin main
# Option B: Pull with merge
git pull origin main
# Resolve any conflicts if prompted
git push origin mainProblem 3: "You have divergent branches and need to specify how to reconcile them"
Git 2.27+ requires you to explicitly choose a pull strategy. Set your preferred default:
# Set rebase as default pull strategy (recommended)
git config --global pull.rebase true
# Or set merge as default
git config --global pull.rebase false
# Or only allow fast-forward pulls
git config --global pull.ff onlyProblem 4: "detached HEAD state"
You checked out a specific commit instead of a branch. Any commits you make in this state are not attached to any branch and can be lost. Fix it by creating a branch from your current position:
# Create a branch from detached HEAD
git switch -c my-recovery-branch
# Or return to a branch
git switch mainProblem 5: Accidentally committed to the wrong branch
Move your latest commit to the correct branch without losing any changes:
# Save the commit hash
COMMIT=$(git rev-parse HEAD)
# Reset main back one commit (keeps changes staged)
git reset --soft HEAD~1
# Switch to the correct branch and apply
git switch correct-branch
git cherry-pick $COMMITProblem 6: Need to undo the last commit
There are three levels of undoing commits, each with different consequences:
# Undo commit, keep changes staged
git reset --soft HEAD~1
# Undo commit, keep changes unstaged
git reset --mixed HEAD~1
# Undo commit AND discard all changes (DESTRUCTIVE)
git reset --hard HEAD~1
# If already pushed, use revert instead (creates a new commit)
git revert HEADProblem 7: "Permission denied (publickey)"
Your SSH key is not loaded or not added to your Git hosting provider. Verify your key is loaded with ssh-add -l. If empty, add your key with ssh-add ~/.ssh/id_ed25519. Verify the key is added to your GitHub/GitLab account settings. Test with ssh -T [email protected].
Problem 8: Repository size is too large / slow clone
Large repositories with binary files or accumulated history can be slow to clone. Use shallow or partial clones:
# Shallow clone (last 10 commits only)
git clone --depth 10 [email protected]:org/repo.git
# Blobless clone (full history, blobs on demand)
git clone --filter=blob:none [email protected]:org/repo.git
# If the repo already exists, clean up with gc
git gc --aggressive --prune=now
# Find large files in history
git rev-list --objects --all | git cat-file --batch-check='%(objecttype) %(objectname) %(objectsize) %(rest)' | sort -k3 -n -r | head -20Problem 9: Recovering deleted branches or lost commits
Git's reflog records every HEAD movement for the last 90 days. Even after deleting a branch or doing a hard reset, you can recover lost commits:
# View the reflog
git reflog
# Recover a deleted branch
git branch recovered-branch abc1234
# Recover after a hard reset
git reflog
# Find the commit before the reset
git reset --hard HEAD@{2}Problem 10: ".gitignore is not working"
If a file was already tracked before you added it to .gitignore, Git continues tracking it. You must explicitly untrack it:
# Untrack a file (keeps the local copy)
git rm --cached .env
# Untrack an entire directory
git rm -r --cached node_modules/
# Commit the removal
git commit -m "chore: remove tracked files now in .gitignore"Advanced Tips for Power Users
Once you have mastered the fundamentals of this git tutorial, these advanced techniques will dramatically increase your productivity. These are the commands and configurations that separate senior engineers from juniors.
Git Aliases let you create shortcuts for frequently used commands. Add these to your ~/.gitconfig to save hundreds of keystrokes per day:
# Add useful aliases
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.lg "log --oneline --graph --all --decorate"
git config --global alias.last "log -1 HEAD --stat"
git config --global alias.unstage "reset HEAD --"
git config --global alias.amend "commit --amend --no-edit"
git config --global alias.wip "commit -am 'WIP: work in progress'"
# Now use them
git lg # Beautiful graph log
git st # Short status
git last # Last commit detailsGit Submodules embed one repository inside another. They are essential for managing shared libraries or components across multiple projects:
# Add a submodule
git submodule add [email protected]:org/shared-lib.git libs/shared
# Clone a repo with submodules
git clone --recurse-submodules [email protected]:org/project.git
# Update all submodules to latest
git submodule update --remote --merge
# Initialize submodules after a regular clone
git submodule init
git submodule updateSigned Commits with GPG or SSH keys prove that commits actually came from the claimed author. GitHub and GitLab show a "Verified" badge on signed commits. In 2026, SSH signing is the preferred method because it uses keys you already have:
# Configure SSH signing (Git 2.34+)
git config --global gpg.format ssh
git config --global user.signingkey ~/.ssh/id_ed25519.pub
git config --global commit.gpgsign true
# Create a signed commit
git commit -S -m "feat: verified change"
# Verify signatures
git log --show-signatureGit Rerere (Reuse Recorded Resolution) remembers how you resolved merge conflicts and automatically applies the same resolution when it encounters the same conflict again. This is invaluable when rebasing long-lived branches:
# Enable rerere globally
git config --global rerere.enabled true
# After resolving a conflict, rerere records it automatically
# Next time the same conflict appears, Git resolves it for youGit 2.52 and the Road to Git 3.0: What Changes in 2026
Git is approaching its most significant major release since version 2.0 in 2014. Git 3.0 is targeted for late 2026 and introduces several breaking changes that developers should prepare for now. Understanding these changes is critical for teams planning their toolchain strategy for the coming years.
The most impactful change in Git 3.0 is the default switch from SHA-1 to SHA-256 for the object hash algorithm. SHA-1 has been theoretically broken since the SHAttered attack in 2017, and while Git has used a hardened SHA-1 variant since version 2.29, enterprise security teams have been pushing for the full transition. New repositories created with Git 3.0 will use SHA-256 by default, producing 64-character commit hashes instead of the familiar 40-character SHA-1 hashes.
The reftable backend replaces the traditional loose-reference and packed-reference storage with a binary format originally developed by Google for the JGit implementation. Benefits include atomic multi-reference updates (no more filesystem race conditions), case-sensitive reference storage on all platforms, and dramatically faster reads in repositories with thousands of branches and tags.
Git 2.52.0 itself landed in November 2025, and the project's momentum only built from there: Git 2.55.0, released in June 2026, drew contributions from more than 100 developers, including 33 first-time contributors, demonstrating the health and growth of the Git open-source community. The git describe command received a 30% speed improvement through the use of priority queues, and sparse index support was extended to git ls-files for faster operations in sparse checkout environments.
To prepare your repositories for Git 3.0, start enabling SHA-256 and reftable on new projects now. Existing repositories can be migrated once the hash interoperability layer is fully stabilized, which is expected in Git 2.53 or 2.54.
Complete Working Project: Task Manager with Full Git Workflow
Let us bring everything together with a complete project setup that demonstrates a professional Git workflow from initialization through a simulated pull request cycle. This section creates a fully working Node.js task manager application with proper version control practices applied at every step.
# Initialize project with package.json
cd git-tutorial-project
npm init -y
# Install dependencies
npm install uuid
npm install --save-dev jest eslint
# Update package.json scripts
npx json -I -f package.json -e 'this.scripts.test="jest"'
npx json -I -f package.json -e 'this.scripts.lint="eslint src/"'
# Create a comprehensive .gitignore
cat > .gitignore << 'EOF'
node_modules/
dist/
coverage/
.env
.env.*
*.log
.DS_Store
Thumbs.db
.vscode/settings.json
EOF
# Stage and commit the project setup
git add package.json package-lock.json .gitignore
git commit -m "chore: initialize npm project with jest and eslint"
# Create feature branch for tests
git switch -c feature/add-tests
# Write tests
cat > tests/app.test.js << 'EOF'
const { TaskManager } = require('../src/app');
describe('TaskManager', () => {
let manager;
beforeEach(() => {
manager = new TaskManager();
});
test('should add a task with default priority', () => {
const task = manager.addTask('Write documentation');
expect(task.title).toBe('Write documentation');
expect(task.priority).toBe('medium');
expect(task.completed).toBe(false);
});
test('should complete a task', () => {
const task = manager.addTask('Deploy to production');
const completed = manager.completeTask(task.id);
expect(completed.completed).toBe(true);
expect(completed.completedAt).toBeDefined();
});
test('should filter tasks by status', () => {
manager.addTask('Task 1');
const task2 = manager.addTask('Task 2');
manager.completeTask(task2.id);
expect(manager.listTasks('pending')).toHaveLength(1);
expect(manager.listTasks('completed')).toHaveLength(1);
expect(manager.listTasks('all')).toHaveLength(2);
});
test('should throw when completing non-existent task', () => {
expect(() => manager.completeTask('invalid-id')).toThrow();
});
});
EOF
# Commit tests
git add tests/app.test.js
git commit -m "test: add unit tests for TaskManager core methods"
# Run tests to verify
npm test
# Push feature branch and create PR
git push -u origin feature/add-tests
# After review, merge to main
git switch main
git merge --no-ff feature/add-tests -m "merge: add TaskManager unit tests"
git branch -d feature/add-tests
git push origin main
# Tag the release
git tag -a v1.0.0 -m "v1.0.0: initial release with core task management"
git push origin v1.0.0This workflow demonstrates the complete lifecycle: branch creation, isolated development, testing, merge with preserved history (using --no-ff), cleanup, and semantic versioning with annotated tags. Every professional team follows a variation of this pattern.
Essential Git Commands Quick Reference
Keep this reference table handy as you work through your daily Git operations. These commands cover 95% of what you need in professional development:
| Category | Command | Description |
|---|---|---|
| Setup | git init | Create a new repository |
| Setup | git clone <url> | Clone a remote repository |
| Staging | git add <file> | Stage specific file |
| Staging | git add -p | Interactively stage hunks |
| Committing | git commit -m "msg" | Commit staged changes |
| Committing | git commit --amend | Modify the last commit |
| Branching | git switch -c <name> | Create and switch to branch |
| Branching | git branch -d <name> | Delete a merged branch |
| Merging | git merge <branch> | Merge branch into current |
| Merging | git rebase <branch> | Rebase onto another branch |
| Remote | git push -u origin <branch> | Push and set upstream |
| Remote | git pull --rebase | Pull with rebase strategy |
| History | git log --oneline --graph | Visual commit history |
| History | git blame <file> | Show who changed each line |
| Undo | git reset --soft HEAD~1 | Undo last commit, keep staged |
| Undo | git revert <commit> | Create undo commit |
| Stash | git stash push -m "msg" | Save work in progress |
| Tags | git tag -a v1.0 -m "msg" | Create annotated tag |
Related Coverage
Deepen your development skills with these related guides from our tutorial series:
- GitHub vs GitLab 2026: The Leading DevOps Platform Comparison
- How to Build a CI/CD Pipeline with GitHub Actions: Complete Tutorial (2026)
- How to Get Started with Docker: Complete Beginner Tutorial (2026)
- How to Learn TypeScript from Scratch: Complete Beginner to Advanced Tutorial (2026)
- How to Build a Full-Stack App with Next.js 15: Complete Tutorial (2026)
- AI Coding Tools in 2026: The Guide
Frequently Asked Questions About Git
What is the difference between Git and GitHub?
Git is the version control system that runs locally on your machine. GitHub is a cloud platform that hosts Git repositories and adds features like pull requests, issue tracking, CI/CD with GitHub Actions, and team collaboration tools. You can use Git without GitHub by hosting repositories on GitLab, Bitbucket, or your own server. Git was created by Linus Torvalds in 2005, while GitHub was founded in 2008 and acquired by Microsoft in 2018 for $7.5 billion. As of October 2025, GitHub hosted more than 180 million developers and over 630 million repositories, according to GitHub's own Octoverse report as summarized by Poster.ly, cementing its position as the default home for Git-tracked code. GitHub reinforces this distinction through its own education tooling too – its official Git skills course shows a latest commit dated April 2026, reflecting how actively the platform keeps its Git teaching material updated.
Should I use merge or rebase?
Use rebase for local branches that have not been pushed to a shared remote. Rebase creates a cleaner, linear history that is easier to read. Use merge (specifically --no-ff) for integrating completed feature branches into main, as it preserves the context of when the feature was developed and merged. The golden rule: never rebase commits that other people have based work on.
How do I undo a commit that has already been pushed?
Use git revert <commit-hash> to create a new commit that undoes the changes from the specified commit. This is safe for shared branches because it does not rewrite history. Never use git reset on commits that have been pushed, as this rewrites history and breaks the repository for anyone who has already pulled those commits.
What is the best Git branching strategy for a small team?
For teams of 2-10 developers, GitHub Flow is the recommended strategy. Create a feature branch for every change, open a pull request for code review, run automated tests in CI, and merge to main with a squash merge. The main branch should always be deployable. Avoid GitFlow (with develop, release, and hotfix branches) unless you are managing multiple production versions simultaneously.
How do I remove a file from Git history completely?
Use git filter-repo (the modern replacement for the deprecated git filter-branch). Install it with pip install git-filter-repo, then run git filter-repo --invert-paths --path secret-file.env. This rewrites the entire repository history, so all team members must re-clone afterwards. For less drastic cases, consider using BFG Repo-Cleaner which is faster for removing large files or passwords.
What is Git LFS and when should I use it?
Git Large File Storage (LFS) replaces large files in your repository with lightweight pointers, storing the actual file contents on a separate server. Use Git LFS for binary files over 10 MB: images, videos, datasets, compiled binaries, and design assets. Without LFS, large files bloat the repository permanently because Git stores every version of every file. Enable it with git lfs install and track file patterns with git lfs track "*.psd".
Is Git 3.0 backward compatible?
Git 3.0 is backward compatible for existing repositories. Your current SHA-1 repositories will continue to work without any changes. The breaking changes primarily affect defaults for new repositories: SHA-256 becomes the default hash, reftable becomes the default reference storage, and some deprecated commands will be removed. Teams can prepare by testing SHA-256 and reftable on non-critical projects now using Git 2.52.
How do I speed up Git in a large monorepo?
Enable sparse checkout to only download the directories you work on (git sparse-checkout set src/my-service). Turn on the commit-graph feature (git commit-graph write --reachable) for faster log and merge operations. Use partial clones (git clone --filter=blob:none) to avoid downloading every blob on initial clone. Finally, enable git maintenance start to run background optimization tasks. These techniques combined can reduce Git operation times by 90% or more in repositories with millions of files.
