Git Tips Every Developer Should Know - Beyond the Basics

Sanjeev SharmaSanjeev Sharma
5 min read

Advertisement

Introduction

Most developers use about 10% of Git's capabilities — add, commit, push, pull. But mastering Git's advanced features can save you hours every week and make you a dramatically better collaborator.

Here are the tips that will level up your Git game immediately.

1. Interactive Rebase — Rewrite History Cleanly

Interactive rebase lets you edit, squash, reorder, and split commits before pushing:

# Rebase the last 5 commits interactively
git rebase -i HEAD~5

You'll see an editor with options for each commit:

pick abc1234 Add user model
pick def5678 Fix typo in user model
pick ghi9012 Add user controller
pick jkl3456 WIP: user service
pick mno7890 Finish user service

# Commands:
# p, pick = use commit
# r, reword = use commit but edit message
# s, squash = squash into previous commit
# f, fixup = squash but discard message
# d, drop = remove commit

Change pick to squash to combine messy WIP commits into one clean commit before pushing.

2. git stash — Save Work Without Committing

# Stash your current changes
git stash

# Stash with a description
git stash push -m "WIP: user auth feature"

# List all stashes
git stash list
# stash@{0}: On main: WIP: user auth feature
# stash@{1}: On main: Quick fix attempt

# Apply and remove the latest stash
git stash pop

# Apply a specific stash (without removing it)
git stash apply stash@{1}

# Stash only specific files
git stash push -m "api changes" src/api/users.ts

# Delete all stashes
git stash clear

3. git bisect — Find the Commit that Broke Everything

# Start bisect session
git bisect start

# Mark current commit as bad
git bisect bad

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

# Git will checkout the middle commit — test it
# If it's bad:
git bisect bad
# If it's good:
git bisect good

# Git automatically narrows down — binary search!
# Eventually tells you exactly which commit introduced the bug

# Reset when done
git bisect reset

This finds the exact breaking commit in O(log n) steps — a 1000-commit history takes just 10 steps!

4. git reflog — Undo Anything

reflog is your safety net. It records every position HEAD has been at:

git reflog
# HEAD@{0}: commit: Add new feature
# HEAD@{1}: reset: moving to HEAD~1
# HEAD@{2}: commit: Oops, bad commit
# HEAD@{3}: checkout: moving from feature to main

# Recover a "lost" commit
git checkout HEAD@{2}

# Recover after an accidental reset --hard
git reset --hard HEAD@{3}

Almost nothing in Git is truly lost if you act within 90 days (the reflog expiry).

5. Useful git log Formats

# Beautiful one-line log
git log --oneline --graph --all --decorate

# Show commits with file diffs
git log -p

# Show commits that changed a specific file
git log --follow -p src/components/Button.tsx

# Show commits between two dates
git log --after="2026-01-01" --before="2026-03-01"

# Show commits by author
git log --author="Alice"

# Search commits by message
git log --grep="fix auth"

# My favorite alias
git log --oneline --graph --decorate --all

6. git cherry-pick — Apply Specific Commits

# Apply a specific commit from another branch to current branch
git cherry-pick abc1234

# Cherry-pick a range of commits
git cherry-pick abc1234..def5678

# Cherry-pick without committing (just apply changes)
git cherry-pick --no-commit abc1234

Useful when you've fixed a bug on main and need that exact fix on a release branch too.

7. Git Aliases — Stop Typing Long Commands

Add these to your ~/.gitconfig:

[alias]
  st = status
  co = checkout
  br = branch
  ci = commit
  lg = log --oneline --graph --decorate --all
  undo = reset HEAD~1 --mixed
  unstage = reset HEAD --
  last = log -1 HEAD
  wip = commit -am "WIP"
  unwip = reset HEAD~1 --mixed
  aliases = config --get-regexp alias

Now you can just type git lg or git undo.

8. git diff Tips

# See what you're about to commit
git diff --staged

# Compare two branches
git diff main..feature-branch

# Compare specific files between branches
git diff main feature-branch -- src/api/users.ts

# Show only file names that changed
git diff --name-only main..HEAD

# Word-level diff (easier to read)
git diff --word-diff

9. Undoing Things

# Undo last commit but keep changes staged
git reset HEAD~1 --soft

# Undo last commit and unstage changes
git reset HEAD~1 --mixed

# Undo last commit AND discard changes (dangerous!)
git reset HEAD~1 --hard

# Undo a specific commit by creating a new commit
git revert abc1234  # Safe for shared branches

# Unstage a file
git restore --staged file.txt

# Discard local changes to a file
git restore file.txt

10. .gitignore Tips

# Create a .gitignore based on your project type
# Visit gitignore.io or use GitHub's templates

# See what's being ignored
git check-ignore -v filename

# Force add an ignored file
git add -f file.txt

# Remove a file from tracking (but keep it locally)
git rm --cached sensitive-file.txt

Conclusion

Git is one of those tools where learning 10 extra commands saves you 10 hours a week. Master rebase -i for clean commits, stash for context switching, bisect for debugging, and reflog as your safety net. These habits separate senior engineers from everyone else.

Advertisement

Sanjeev Sharma

Written by

Sanjeev Sharma

Full Stack Engineer · E-mopro