Git Essentials: The Commands Every Developer Needs to Know

Git: The Version Control System That Runs the World

Git is the most widely used version control system in software development. Created by Linus Torvalds in 2005 to manage the Linux kernel source code, it's now the backbone of nearly every software project. Understanding Git is not optional for modern developers — it's table stakes.

Initial Setup

Before using Git, configure your identity. This information is embedded in every commit you make:

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git config --global core.editor "vim"   # or nano, code, etc.
git config --global init.defaultBranch main

Starting a Repository

• git init — initialize a new repository in the current directory
• git clone <url> — clone an existing remote repository locally
• git clone <url> my-folder — clone into a specific folder name

The Core Workflow: Stage, Commit, Push

Git's workflow revolves around three areas: the working directory (your files), the staging area (what will be committed), and the repository (the history).

# Check the status of your working directory
git status

# Stage specific files
git add filename.py

# Stage all changes in current directory
git add .

# Commit staged changes with a message
git commit -m "Add login validation function"

# Push commits to the remote repository
git push origin main

Branching and Merging

Branches let you work on features or fixes in isolation without affecting the main codebase:

# Create and switch to a new branch
git checkout -b feature/user-auth

# List all branches
git branch -a

# Switch to an existing branch
git checkout main

# Merge a branch into current branch
git merge feature/user-auth

# Delete a merged branch
git branch -d feature/user-auth

Viewing History and Differences

# View commit history
git log

# Compact one-line log
git log --oneline --graph --decorate

# See what changed in a commit
git show abc1234

# See unstaged changes
git diff

# See staged changes
git diff --staged

Undoing Mistakes

Git gives you multiple ways to undo changes — choose the right tool for the situation:

Scenario	Command
Discard unstaged changes in a file	git checkout -- filename
Unstage a staged file	git reset HEAD filename
Amend the last commit message	git commit --amend -m "New message"
Revert a published commit safely	git revert <commit-hash>
Reset to a previous commit (destructive)	git reset --hard <commit-hash>

Warning: git reset --hard permanently discards uncommitted changes. Use with caution, especially on shared branches.

Working with Remotes

# List remote connections
git remote -v

# Add a remote
git remote add origin https://github.com/user/repo.git

# Fetch changes without merging
git fetch origin

# Pull (fetch + merge)
git pull origin main

# Push a new branch to remote
git push -u origin feature/new-feature

Git Stash: Save Work Temporarily

Need to switch branches but you're mid-task? Stash saves your uncommitted work:

git stash          # Save changes
git stash list     # List stashes
git stash pop      # Re-apply most recent stash
git stash drop     # Delete most recent stash

Tips for Better Git Usage

• Write meaningful commit messages: Use the imperative mood — "Fix login bug" not "Fixed login bug".
• Commit small and often: Granular commits are easier to review, revert, and understand.
• Never force-push to shared branches: It rewrites history and breaks collaborators' local copies.
• Use .gitignore: Keep secrets, build artifacts, and IDE config files out of your repository.
• Learn interactive rebase: git rebase -i HEAD~3 lets you clean up commit history before merging.

Mastering Git is an investment that pays dividends every single day. Start with the basics, build muscle memory, then graduate to more powerful commands like rebase, bisect, and cherry-pick.