DEV Community

Cover image for Git Commands Every Developer Should Know (The Only Cheat Sheet You Need) šŸš€
Muhammad Hamid Raza
Muhammad Hamid Raza

Posted on

Git Commands Every Developer Should Know (The Only Cheat Sheet You Need) šŸš€

#git #github #programming #productivity

Ever stared at a Git error in your terminal and thought, "What did I even do?" ā€” yeah, we've all been there.

Git is one of those tools that looks scary at first but becomes your best friend once it clicks. Whether you're a student pushing your first project to GitHub or a developer managing branches across a team, Git is everywhere. And if you don't know the right commands, things can go sideways fast.

So here's the real question: Are you using Git to its full potential, or are you just running git add . and hoping for the best? šŸ˜…

This guide breaks down the most important Git commands in a simple, practical way ā€” no fluff, no jargon overload. Let's get into it.

What Is Git?

Git is a version control system ā€” a tool that tracks changes to your code over time.

Think of it like a time machine for your project. Every time you save a checkpoint (called a commit), Git remembers exactly what your code looked like at that moment. If something breaks tomorrow, you can travel back to when everything worked.

It runs locally on your computer, which means it's fast, private, and doesn't require an internet connection. GitHub, GitLab, and Bitbucket are online platforms built on top of Git ā€” they let you store and share your Git repositories in the cloud.

Git is free, open source, and used by virtually every professional development team on the planet.

Why Git Matters

Imagine writing 300 lines of code, then accidentally deleting the wrong file with no way to recover it. Without Git, that's a nightmare.

With Git, it's just a git checkout away from being fixed.

Here's why Git is essential for anyone writing code:

  • It protects your work. Every commit is a backup. You can always go back.
  • It lets teams collaborate. Multiple developers can work on the same project without overwriting each other's code.
  • It keeps history clean. You can see who changed what, when, and why.
  • It's required in real jobs. Almost every tech company uses Git. Knowing it well makes you a better candidate and a better teammate.
  • It removes fear. When you know you can undo mistakes, you experiment more freely. And that's how you grow.

Key Git Commands with Real-Life Examples

āš™ļø Setup & Initialization

Before anything else, Git needs to know who you are.

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git config --global color.ui auto
Enter fullscreen mode Exit fullscreen mode

This sets your name, email, and enables colored output in the terminal. You only do this once per machine.

To start a new Git project:

git init
Enter fullscreen mode Exit fullscreen mode

To download an existing project from GitHub:

git clone https://github.com/username/repo-name
Enter fullscreen mode Exit fullscreen mode

Real-life moment: You join a new team and need to get the codebase. git clone is the first command you'll run.

šŸ“ø Stage & Snapshot (The Core Workflow)

This is where most of your daily Git life happens.

git status
Enter fullscreen mode Exit fullscreen mode

Shows which files you've changed. Run this constantly ā€” it tells you exactly what's going on.

git add [file]
Enter fullscreen mode Exit fullscreen mode

Stages a specific file for commit. Use git add . to stage all changed files at once.

git reset [file]
Enter fullscreen mode Exit fullscreen mode

Unstages a file but keeps your changes. Useful when you accidentally staged something you didn't mean to.

git diff
Enter fullscreen mode Exit fullscreen mode

Shows what changed but hasn't been staged yet.

git diff --staged
Enter fullscreen mode Exit fullscreen mode

Shows what's staged but not yet committed. Great for a final review before committing.

git commit -m "Your descriptive message here"
Enter fullscreen mode Exit fullscreen mode

Saves a snapshot of your staged changes. Always write clear commit messages ā€” future you will thank present you.

Tip: Think of staging like packing a suitcase. git add puts things in. git commit zips it up and labels it.

šŸŒæ Branching & Merging

Branches let you work on new features or fixes without touching the main codebase.

git branch
Enter fullscreen mode Exit fullscreen mode

Lists all your branches. The active one has a * next to it.

git branch [branch-name]
Enter fullscreen mode Exit fullscreen mode

Creates a new branch.

git checkout [branch-name]
Enter fullscreen mode Exit fullscreen mode

Switches to a different branch.

git merge [branch]
Enter fullscreen mode Exit fullscreen mode

Merges another branch into your current one.

git log
Enter fullscreen mode Exit fullscreen mode

Shows the full commit history of the current branch.

Real-life example: You're adding a dark mode feature. Create a feature/dark-mode branch, build it there, test it, then merge it into main when it's ready. The main branch stays clean the whole time.

šŸŒ Share & Update (Remote Repos)

Working with GitHub or any remote server requires these commands.

git remote add origin [url]
Enter fullscreen mode Exit fullscreen mode

Links your local repo to a remote one.

git fetch origin
Enter fullscreen mode Exit fullscreen mode

Downloads updates from the remote without applying them yet.

git pull
Enter fullscreen mode Exit fullscreen mode

Fetches and merges changes from the remote branch. This is how you stay up to date with your team.

git push origin [branch]
Enter fullscreen mode Exit fullscreen mode

Sends your local commits to the remote repository.

Common situation: Your teammate merged new code while you were working. Run git pull to sync up before pushing your own changes.

šŸ” Inspect & Compare

Sometimes you need to investigate what happened and when.

git log
Enter fullscreen mode Exit fullscreen mode

Full commit history for the active branch.

git log branchB..branchA
Enter fullscreen mode Exit fullscreen mode

Shows commits in branchA that aren't in branchB. Useful before merging.

git log --follow [file]
Enter fullscreen mode Exit fullscreen mode

Tracks a file's history ā€” even if it was renamed.

git diff branchB...branchA
Enter fullscreen mode Exit fullscreen mode

Shows what's in branchA that's not in branchB.

git show [SHA]
Enter fullscreen mode Exit fullscreen mode

Shows the details of any specific commit by its hash.

šŸ“‚ Tracking Path Changes

When you rename or delete files, Git needs to know.

git rm [file]
Enter fullscreen mode Exit fullscreen mode

Deletes the file and stages that deletion for the next commit.

git mv [old-path] [new-path]
Enter fullscreen mode Exit fullscreen mode

Renames or moves a file and stages the change automatically.

git log --stat -M
Enter fullscreen mode Exit fullscreen mode

Shows commit history with info about any file paths that moved.

šŸ—‚ļø Temporary Commits (Stashing)

Sometimes you're in the middle of something and need to switch branches quickly ā€” but you're not ready to commit.

git stash
Enter fullscreen mode Exit fullscreen mode

Temporarily saves your current work and cleans the working directory.

git stash list
Enter fullscreen mode Exit fullscreen mode

Shows all your stashed changes in order.

git stash pop
Enter fullscreen mode Exit fullscreen mode

Applies the most recent stash and removes it from the list.

git stash drop
Enter fullscreen mode Exit fullscreen mode

Discards the most recent stash entirely.

Real-life moment: Your manager asks for an urgent bug fix, but you're halfway through a new feature. git stash saves your progress, you fix the bug, then git stash pop brings your work right back. šŸ’”

ā™»ļø Rewrite History

These are powerful commands ā€” use them carefully.

git rebase [branch]
Enter fullscreen mode Exit fullscreen mode

Moves your current branch's commits on top of another branch. Keeps history clean and linear.

git reset --hard [commit]
Enter fullscreen mode Exit fullscreen mode

Resets your entire working directory to a specific commit. This is destructive ā€” it removes all uncommitted changes.

šŸš« Ignoring Files

Not every file belongs in your repo. Use a .gitignore file to tell Git what to skip.

logs/
*.notes
pattern*/
Enter fullscreen mode Exit fullscreen mode

Or set a global ignore pattern for all your repos:

git config --global core.excludesfile [file]
Enter fullscreen mode Exit fullscreen mode

Common things to ignore: node_modules/, .env files, build outputs, OS files like .DS_Store.

Git vs No Version Control

Without Git With Git
Files named final_v2_REAL_final.js Clean commit history
One accidental delete ruins everything Always recoverable
Hard to collaborate Teams work in parallel
No record of changes Full audit trail
Fear of breaking things Freedom to experiment

Best Tips for Using Git Effectively āœ…

  • Commit often, not rarely. Small, frequent commits are easier to understand and revert than one massive commit at the end.
  • Write meaningful commit messages. "Fixed stuff" tells no one anything. "Fix null pointer in user login flow" is actually useful.
  • Always pull before you push. Sync up with your team's latest changes before sending your own.
  • Use branches for everything. Features, bug fixes, experiments ā€” keep them separate from main.
  • Check git status constantly. It's your dashboard. Get in the habit of running it before any action.
  • Never force-push to shared branches. It can overwrite your teammates' work.

Common Mistakes People Make

1. Committing directly to main
Many beginners skip branching and commit everything straight to main. This works alone but breaks everything in a team. Always branch.

2. Vague commit messages
Messages like "update" or "changes" are useless after a week. Write messages that describe what changed and why.

3. Forgetting to pull before pushing
This causes merge conflicts. Get into the habit of git pull first, every single time.

4. Staging everything blindly with git add .
Sometimes you have test files or debug logs you don't want in the repo. Use git status first, then stage selectively.

5. Not using .gitignore
Committing node_modules or .env files is a very common beginner mistake. Set up your .gitignore early.

6. Using git reset --hard carelessly
This command deletes uncommitted work permanently. Double-check before running it.

Conclusion

Git is one of the most valuable tools a developer can master ā€” and the good news is, you don't need to memorize every command on day one. Start with the basics: init, add, commit, push, and pull. Then gradually add branching, stashing, and rebasing to your workflow.

The more you use Git, the more natural it becomes. And once it clicks, you'll wonder how you ever coded without it.

Bookmark this post for quick reference whenever you need a command. And if you want more practical guides like this one, check out hamidrazadev.com ā€” there's a lot more waiting for you there. šŸš€

If this post helped you, share it with a fellow developer who's still copy-pasting random Git commands from Stack Overflow. You might just save their day. šŸ˜Š

Top comments (0)