Introduction
Git is not just a tool — it’s the lifeline of modern software development. Yet, many junior developers underestimate its power. If you don’t master Git early, you’ll soon find yourself drowning in broken branches, lost commits, and unsolvable merge conflicts. This guide covers the absolute must-know Git commands that every junior developer should engrain into their muscle memory.
1. git init
What it does: Initializes a new Git repository.
If you’re starting a new project, run:
git init
Without this, Git won’t track your project. Forget this step, and you’re just coding in the void.
2. git clone
What it does: Clones a repository from a remote source.
git clone <repository-url>
When you join a team or contribute to an open-source project, this is how you grab the code.
3. git status
What it does: Shows the current state of your working directory.
git status
Before making any changes, always check git status. It prevents you from pushing unfinished code or committing the wrong files.
4. git add
What it does: Stages changes for the next commit.
git add <filename>
Or add all changes:
git add .
Skipping this step means your changes won’t be included in your next commit. Rookie mistake.
5. git commit -m “your message”
What it does: Saves changes with a descriptive message.
git commit -m “Added user authentication module”
Always write clear and concise commit messages — future you will thank you.
Here is my article about how to write commits and document git projects:
Practices for Maintainable and Future-Proof Projects
6. git push
What it does: Sends your committed changes to the remote repository.
git push origin <branch-name>
If you don’t push, your teammates won’t see your work. Forgetting this could lead to merge hell.
7. git pull
What it does: Fetches and integrates changes from the remote repository.
git pull origin <branch-name>
Skipping this before pushing can cause conflicts that will ruin your day.
8. git branch
What it does: Lists or creates branches.
git branch
Create a new branch:
git branch <new-branch-name>
Always work in branches! Never push directly to main unless you enjoy total chaos.
9. git checkout
What it does: Switches between branches.
git checkout <branch-name>
Switching branches without committing changes? Say goodbye to your work.
10. git merge
What it does: Merges one branch into another.
git merge <branch-name>
ALWAYS resolve conflicts properly — otherwise, your team will hate you.
11. git reset
What it does: Undoes changes.
git reset — hard HEAD~1
This command is powerful — and dangerous. Use it wisely, or you might lose hours of work in an instant.
12. git log
What it does: Shows commit history.
git log — oneline
Need to find out who broke the code? Start here.
13. git stash
What it does: Temporarily saves changes without committing them.
git stash
For when you need to switch branches but don’t want to commit half-baked code.
14. git rebase
What it does: Moves or combines commits.
git rebase main
Rebasing keeps your commit history clean — but misuse it, and you’ll corrupt your repository.
15. git revert
What it does: Undoes a commit safely.
git revert <commit-hash>
Unlike git reset, this keeps history intact, making it a safer option for rolling back changes.
Conclusion
Ignoring Git is not an option if you want to survive as a developer. Master these commands, and you’ll avoid embarrassing mistakes, save time, and gain the respect of your peers. Git is unforgiving — either you control it, or it controls you.
Which of these commands has saved you from disaster? Let me know in the comments!
Top comments (0)