15 Advanced Git Tricks Developers Love Using

Introduction to Advanced Git Features

Git is far more than just a version control system—it’s the backbone of modern software collaboration. Whether you’re managing microservices, automating CI/CD pipelines, or contributing to open source, mastering advanced Git features transforms you from a casual user into a DevOps powerhouse.

This guide dives deep into the commands, workflows, and hidden features that help teams manage complex repositories, recover lost work, and maintain a clean, readable project history.

Understanding Git’s Core Architecture

At its core, Git is a snapshot-based system rather than a delta-based tracker. Every commit points to a tree (snapshot) of the project state; objects are content-addressed and deduplicated, so unchanged files aren’t duplicated. Pointers connect commits in a Directed Acyclic Graph (DAG).

This architecture enables powerful features like branching, merging, and rebasing with minimal overhead. For DevOps teams, this structure allows seamless integration across CI/CD systems, rollbacks, and automated deployment pipelines.

Advanced Branching Strategies

Using git switch and git restore

The git switch and git restore commands simplify operations previously done with git checkout. For example:

# **Create and switch to a new branch**
git switch -c feature/login-ui

# **Switch to an existing branch**
git switch feature/login-ui

# **Unstage a file (keep working changes)**
git restore --staged main.py

# **Discard working-tree changes to a file**
git restore main.py

# **Create and switch to a new branch**gitswitch-cfeature/login-ui# **Switch to an existing branch**gitswitchfeature/login-ui# **Unstage a file (keep working changes)**gitrestore--stagedmain.py# **Discard working-tree changes to a file**gitrestoremain.py

Note: git switch feature/login-ui switches to an existing branch. To create and switch, use git switch -c feature/login-ui.

This improves readability and prevents accidental branch or file changes.

Managing Feature Branches Efficiently

Use a feature branch workflow to isolate new features:

feature/<ticket-id>-<feature-name>
Example: feature/123-user-authentication.

feature/<ticket-id>-<feature-name>Example:feature/123-user-authentication.

This naming pattern keeps branches organized and easily traceable.

Working with Long-Lived Branches

Branches like main, develop, and release (if your workflow uses them—trunk-based teams may keep only main) are typically maintained permanently. Teams merge features into develop, then release to main after QA approval

Advanced Merging Techniques

The Power of git rebase

Rebasing rewrites commit history to keep it linear.
Instead of this:

A---B---C (main)
     \
      D---E (feature)

A---B---C(main)\D---E(feature)

You get:

A---B---C---D'---E' (feature)

A---B---C---D'---E'(feature)

This results in a cleaner, more understandable history.

Caution: don’t rebase commits that others have already pulled (avoid rewriting published history). Use git push --force-with-lease if you must update a remote after a rebase.

Using git cherry-pick for Selective Commits

git cherry-pick allows you to apply specific commits from one branch to another—ideal for backporting bug fixes.

git cherry-pick 1a2b3c4

gitcherry-pick1a2b3c4

Note: cherry-picking can duplicate changes if the original branch is later merged; watch for conflicts.

The Magic of git merge --squash

Combine multiple commits into one before merging. This keeps your main branch history tidy and easy to read.

git merge --squash feature/123-user-authentication
git commit -m "feat(auth): add authentication flow"

gitmerge--squashfeature/123-user-authenticationgitcommit-m"feat(auth): add authentication flow"

Squash merges don’t create a merge commit or preserve parentage—great for tidy history, but the ancestry will not reflect a true merge.

Commit History Management and Cleanup

git commit --amend

Need to fix a commit message or add forgotten changes? Simply run:

git commit --amend

gitcommit--amend

Use on unpublished commits; avoid amending commits others have pulled

This replaces the previous commit without cluttering your history.

git rebase -i (Interactive Rebase)

Interactive rebasing lets you reorder, squash, or edit commits for a refined commit log:

git rebase -i HEAD~5

gitrebase-iHEAD~5

Using git reflog to Recover Lost Commits

Accidentally deleted a branch? Use:

git reflog

gitreflog

It records local Git actions—entries expire per gc.reflogExpire*; recovery is local to your clone.

Git Hooks: Automate Your Workflow

Automation is one of the most underrated advanced Git features. Git hooks are scripts that automatically run when certain Git events occur, such as committing or pushing code. They’re stored in the .git/hooks/ directory of your repository. You can centralize hook scripts via core.hooksPath to share them across repos.

Common Hook Examples (pre-commit, pre-push)

• pre-commit: Runs before you make a commit. Ideal for linting, formatting, or running unit tests automatically.

#!/bin/sh
npm run lint
npm test

#!/bin/shnpmrunlintnpmtest

• pre-push: Executes before pushing to a remote. You can block pushes if tests fail, ensuring broken code never reaches production.

Using Husky or Lefthook for Hook Management

Instead of managing scripts manually, developers use tools like Husky or Lefthook.
These tools allow centralized hook management and integration with CI/CD workflows ——remember client-side hooks don’t enforce policy on the server; pair with CI or server-side hooks.

Working with Remotes and Collaboration

Managing multiple remotes efficiently is vital in DevOps pipelines and open-source collaboration.

git remote prune and git fetch --prune

When collaborators delete branches from the remote, your local repo may still show outdated references.

Clean them up with:

# **Fetch and prune tracking refs in one step**
git fetch --prune

# **Prune stale tracking refs for a specific remote (no fetch)**
git remote prune origin

# **Fetch and prune tracking refs in one step**gitfetch--prune# **Prune stale tracking refs for a specific remote (no fetch)**gitremotepruneorigin

Use git branch -vv to review local branches and prune safely.

Handling Forks and Upstream Syncs

If you’re working on a forked repository:

git remote add upstream https://github.com/original/repo.git
git fetch upstream
# **Rebase (linear history) or merge (preserve history)**
git rebase upstream/main   # or: git merge upstream/main

gitremoteaddupstreamhttps://github.com/original/repo.gitgitfetchupstream# **Rebase (linear history) or merge (preserve history)**gitrebaseupstream/main# or: git merge upstream/main

Rebase keeps your fork tidy; merge preserves the original history.

Debugging and Exploring Commits

git bisect for Locating Bugs

git bisect is an incredibly powerful command that uses binary search to pinpoint which commit introduced a bug.

Example:

git bisect start
git bisect bad HEAD
git bisect good v1.0.0
# **Automate checks**
# git bisect run ./run-tests.sh

gitbisectstartgitbisectbadHEADgitbisectgoodv1.0.0# **Automate checks**# git bisect run ./run-tests.sh

Git will check out commits between these points until it identifies the bad one — a lifesaver in large projects.

git blame for Tracking Code Changes

When investigating a line of code:

git blame main.py

gitblamemain.py

It tells you who made each change and when. Perfect for audits, code reviews, and debugging regressions.

Stashing and Work-in-Progress Management

Developers often switch contexts mid-task. Instead of committing incomplete work, use Git’s stash feature.

git stash push, git stash pop, and git stash apply

• git stash push -m "WIP: new API integration" – saves your changes without committing.
• git stash pop – re-applies and removes the stash entry.
• git stash apply – reapplies without removing, useful for reusing stashed changes.

You can view all stashes with:

git stash push -m "WIP: new API integration"          # saves your changes
git stash list                                         # view all stashes
git stash pop                                          # reapplies and removes
git stash apply                                        # reapplies without removing
# **Common options**
# git stash push --include-untracked
# git stash push --staged

gitstashpush-m"WIP: new API integration"# saves your changesgitstashlist# view all stashesgitstashpop# reapplies and removesgitstashapply# reapplies without removing# **Common options**# git stash push --include-untracked# git stash push --staged

If pop conflicts, the stash entry remains—resolve, then drop it.

This workflow is ideal for DevOps engineers juggling multiple hotfixes or deployments.

Advanced Diff and Log Commands

git log --graph and git log --oneline

Visualize your branch structure:

git log --oneline --graph --all

gitlog--oneline--graph--all

This shows a compact, tree-style view — great for understanding merges at a glance.

git diff --cached, git show, and Custom Aliases

• git diff --cached shows staged changes.
• git show <commit> inspects a specific commit’s details.
• Aliases make these commands faster.
  Example in .gitconfig: [alias] lg = log --oneline --graph --decorate --all st = status -sb co = checkout

Custom aliases can drastically speed up everyday Git operations.

Aliases make these faster. Example .gitconfig:

[alias]
  co = switch
  lg = log --oneline --graph --decorate --all
  st = status -sb
  undo = reset --soft HEAD~1   # keeps changes staged; use revert if already pushed
  cleanup = fetch --prune

[alias]co=switchlg=log--oneline--graph--decorate--allst=status-sbundo=reset--softHEAD~1# keeps changes staged; use revert if already pushedcleanup=fetch--prune

Git Submodules and Monorepos

Adding and Updating Submodules

When your project depends on another repository:

git submodule add https://github.com/lib/project.git libs/project
git submodule update --init --recursive   # **after cloning**

gitsubmoduleaddhttps://github.com/lib/project.gitlibs/projectgitsubmoduleupdate--init--recursive# **after cloning**

To update:

git submodule update --remote

gitsubmoduleupdate--remote

Submodules pin a specific commit of the dependency and often put you in a detached HEAD inside the submodule—be deliberate when committing there

Using git sparse-checkout for Large Repos

For massive monorepos, clone only what you need:

# **Combine partial clone with sparse checkout for speed**
git clone --filter=blob:none --sparse https://github.com/org/huge-repo.git
cd huge-repo
git sparse-checkout init --cone
git sparse-checkout set src/utils

# **Combine partial clone with sparse checkout for speed**gitclone--filter=blob:none--sparsehttps://github.com/org/huge-repo.gitcdhuge-repogitsparse-checkoutinit--conegitsparse-checkoutsetsrc/utils

This reduces clone time and keeps workspaces lightweight, a must-have for DevOps pipelines.

Git Configuration and Aliases for Power Users

Setting Up Useful Git Aliases

Developers can save hours weekly by defining shortcuts. Examples:

Aliases make Git faster and more natural to use.

Configuring .gitconfig for Global Productivity

Enhance your global Git experience:

[color]
  ui = auto
[core]
  editor = code --wait
[help]
  autocorrect = 10   # **slightly longer delay; prevents accidental execution**
[commit]
  gpgsign = true

[color]ui=auto[core]editor=code--wait[help]autocorrect=10# **slightly longer delay; prevents accidental execution**[commit]gpgsign=true

Consider help.autocorrect=prompt on newer Git for safer behavior.

You can even auto-correct minor command typos — a small but mighty productivity boost.

Integrating Git with DevOps Tools

Modern CI/CD systems like Jenkins, GitHub Actions, and GitLab CI thrive on Git events.

• Jenkins uses webhooks to trigger builds on every push.
• GitHub Actions allows YAML-based workflows responding to pull requests or tag pushes.
• GitLab pipelines automate testing and deployment right from merge requests.

Example GitHub Actions YAML:

on:
  push:
    branches: [ main ]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm test

on:push:branches:[ main]jobs:build:runs-on:ubuntu-lateststeps:-uses:actions/checkout@v4-run:npmci-run:npmtest

Pair client-side hooks with CI checks to enforce policy centrally.

Integrating Git into your DevOps ecosystem ensures code is tested, reviewed, and deployed automatically — reducing human error.

Security: Ensuring Commit and Release Integrity

Signed Commits and Tags

Use signed commits:

git config commit.gpgsign true
git commit -S -m "Signed commit"

gitconfigcommit.gpgsigntruegitcommit-S-m"Signed commit"

Modern alternative (SSH signing):

git config gpg.format ssh
git config user.signingkey ~/.ssh/id_ed25519.pub
git tag -s v1.2.3 -m "Release 1.2.3"
git push --tags

gitconfiggpg.formatsshgitconfiguser.signingkey~/.ssh/id_ed25519.pubgittag-sv1.2.3-m"Release 1.2.3"gitpush--tags

Use provider verification (e.g., GitHub’s verification) and consider Sigstore for supply-chain workflows.

Extra Power Tools for Pros

• git worktree for multi-branch workflows: git worktree add ../repo-hotfix hotfix/issue-123
• git range-diff to review a rebase’s effects: git range-diff origin/main...feature
• Safer force pushes: git push --force-with-lease

FAQs About Advanced Git Features

Q1: What’s the difference between merge and rebase?
A merge combines histories, while a rebase copies commits onto a new base to produce a linear history. Use rebase for local cleanup; use merge to preserve history; use squash when individual commits aren’t useful.

Q2: Can I recover deleted branches or commits?
Yes! Use git reflog to view and recover lost commits. Remember: reflog is local and entries expire.

Q3: How can I undo a bad merge?
Use:

git revert -m 1 <merge_commit_hash>

gitrevert-m1<merge_commit_hash>

to reverse a merge safely without losing history.

Q4: What are Git hooks used for?
Hooks automate actions like linting, testing, or notifications before/after Git events. Share them with core.hooksPath or a tool like Husky/Lefthook; enforce centrally via CI.

Q5: What’s the best way to handle large repositories?
Use partial clone with sparse checkout:

git clone --filter=blob:none --sparse <url>

gitclone--filter=blob:none--sparse<url>

It reduces local disk usage and improves performance.

Q6: How do I ensure secure Git commits?
Use GPG- or SSH-signed commits and signed tags for integrity and authenticity in enterprise environments.

Conclusion

Mastering advanced Git features is more than a technical skill — it’s a strategic advantage. Developers and DevOps professionals who leverage Git hooks, interactive rebases, and automation tools unlock higher efficiency, cleaner codebases, and more reliable pipelines.

Git evolves continuously, and staying ahead of the curve means embracing these advanced techniques to collaborate smarter, not harder.

You’ve just covered 15+ of the most powerful Git capabilities that can elevate your workflow from good to exceptional.
If you’re serious about mastering Git, explore the official Git Documentation — it’s the ultimate source for deep dives.