Master Git in 30 Days: 35 Essential Commands Every Developer Needs

Why Git feels hard

Git powers most modern software development, but many tutorials start with dense theory about distributed version control and directed‑acyclic graphs, leaving beginners frustrated when they just want to push code.

Three common myths

You must understand internal mechanics first. You can use Git without knowing how the engine works, just like you can drive a car without understanding its engine.

You need to memorize every command. Git has over 150 commands, but only about 35 are needed for everyday work.

Git becomes intuitive once you learn it. It remains powerful but never truly intuitive; accept that and keep moving.

35 essential commands

Everyday core (≈80 % of usage)

git status          # Show changed files and current branch</code>
<code>git add .          # Stage all changes</code>
<code>git commit -m "msg" # Create a snapshot</code>
<code>git push           # Send commits to the remote</code>
<code>git pull           # Incorporate others' changes

Undo series (when you mess up)

git reset --hard HEAD~1   # Discard the last commit and its changes</code>
<code>git revert HEAD          # Create a new commit that undoes the last one (keeps history)</code>
<code>git stash               # Save uncommitted changes temporarily</code>
<code>git stash pop           # Re‑apply the most recent stash

Branch workflow (feature development)

git branch               # List branches</code>
<code>git checkout -b <branch> # Create and switch to a new branch</code>
<code>git merge <branch>      # Merge a branch into the current one</code>
<code>git rebase <branch>     # Reapply commits on top of another base (use with care)

Advanced tricks

git log --oneline       # Compact one‑line history</code>
<code>git diff               # Show actual changes</code>
<code>git blame <file>       # Identify who introduced each line</code>
<code>git cherry-pick <commit> # Apply a specific commit onto the current branch

Git mental model

Working Directory – the current files you are editing.

Staging Area – a temporary “shopping cart” where you collect changes before committing.

Repository – the full history stored locally.

Remote – a copy of the repository on a server (e.g., GitHub, GitLab).

Commands such as git add, git commit, git push and git pull map directly to these concepts.

Suggested learning order

Week 1: Master the basic workflow – add, commit, push, pull.

Week 2: Learn branching – create, switch, merge.

Week 3: Handle merge conflicts – understand markers and resolve them.

Week 4: Time‑travel – use reset, revert, checkout.

Week 5+: Advanced techniques – rebase, cherry‑pick, reflog, custom aliases.

Common mistakes and fixes

Infrequent commits: Commit small changes often; it makes debugging easier.

Avoiding branches: Use lightweight feature branches instead of working directly on main.

Missing .gitignore: Exclude generated files, dependencies, and secrets (e.g., node_modules, .env).

Panic over merge conflicts: Open the conflicted file, edit the markers, then commit.

Simple Git workflow

Pull the latest changes: git pull origin main Create a feature branch: git checkout -b feature/awesome-thing Make changes.

Commit frequently: git commit -m "clear message" Push the branch: git push origin feature/awesome-thing Create a Pull Request (or merge manually).

Code review, merge, and delete the branch.

Recovery scenarios

1. Committed to the wrong branch

git reset HEAD~1          # Undo last commit but keep changes</code>
<code>git checkout correct-branch</code>
<code>git add .</code>
<code>git commit -m "msg"

2. Need to undo the most recent commit

git reset --soft HEAD~1   # Move HEAD back, keep changes staged

3. Pushed unwanted changes (no one has pulled yet)

git reset --hard HEAD~1   # Remove the bad commit locally</code>
<code>git push --force         # Force‑update the remote (use with extreme caution)

4. Pushed unwanted changes that others have already pulled

git revert HEAD           # Create a new commit that undoes the bad one</code>
<code>git push

5. Reset to remote state (everything lost locally)

git fetch origin</code>
<code>git reset --hard origin/main

30‑day mastery plan

Follow the weekly schedule above, practicing the listed commands in a disposable test repository before applying them to real projects. Focus on the 20 % of commands that give 80 % of daily value, and look up the rest only when needed.