If you’re new to Git or only use it occasionally, you’ve likely googled “most useful Git commands” more than once. This guide is for you. It won’t cover everything Git can do, but it focuses on the most practical commands that will save you time and headaches during day-to-day development.

Let’s dive in.

1. git init

Creates a new Git repository in the current folder.

bash
git init

This sets up Git tracking for your project. It creates a .git directory containing metadata about your repo, including commit history, branches, and remote settings.

2. git clone

Creates a local copy of a remote repository.

bash
git clone #repository-url

Example:

bash
git clone https://github.com/test/hello-world.git

This copies all the files, history, and branches from the remote repo.

3. git status

Shows the current state of your working directory and staging area.

bash
git status

You’ll see:

  • Files that have been modified
  • Files that are staged
  • Untracked files

This is one of the most frequently used Git commands.

4. git add

Adds files to the staging area so they’re ready to be committed.

bash
git add #file
bash
git add .
  • git add #file adds a specific file.
  • git add . adds all changes in the current directory and subdirectories.

Tip: Use git status before running this to see which files you’re staging.

5. git commit

Saves a snapshot of your staged changes with a message.

bash
git commit -m "@feature auth added"

Each commit should describe why the changes were made—not just what was changed.

Use clear, concise messages that help teammates (and your future self) understand the history.

6. git diff

Shows differences between your working directory and the staging area or between commits.

bash
git diff # changes not yet staged
bash
git diff --staged # staged but not yet committed

This helps you preview what’s going to be committed or what changed between commits.

7. git log

Displays the commit history.

bash
git log

You’ll see:

  • Commit hashes
  • Author names
  • Dates
  • Commit messages

To simplify the view:

bash
git log --oneline --graph --decorate

This gives a compact visual history with branches and tags.

8. git reset

Resets your staging area or moves HEAD to a different commit.

Undo staged changes:

bash
git reset #file

Undo a commit (but keep your changes):

bash
git reset --soft HEAD~1

Undo a commit and remove changes:

bash
git reset --hard HEAD~1

⚠️ Be careful with --hard — it deletes your changes.

9. git checkout

Switches branches or restores files.

Switch to a branch:

bash
git checkout main

Restore a file to the last committed version:

bash
git checkout -- index.html

Since Git 2.23, the safer alternative is to use:

bash
git restore #file
bash
git switch #branch

10. git branch

Lists, creates, or deletes branches.

List branches:

bash
git branch

Create a new branch:

bash
git branch @feature/login-form

Delete a branch:

bash
git branch -d old-feature

11. git merge

Combines changes from one branch into another.

plaintext
git checkout main
bash
git merge @feature/login-form

This merges the feature branch into the main branch.

If there are conflicting changes in the same files, Git will prompt you to resolve them manually.

12. git pull

Downloads changes from a remote repository and merges them into your local branch.

bash
git pull origin main

This is equivalent to:

bash
git fetch
bash
git merge

Use git pull --rebase to avoid unnecessary merge commits.

13. git push

Uploads your local commits to a remote repository.

bash
git push origin main

Use this to share your work with others.

14. git stash

Temporarily saves changes that you don’t want to commit yet.

bash
git stash

This clears your working directory so you can switch branches cleanly.

Restore stashed changes:

bash
git stash pop

View all stashes:

bash
git stash list

15. git remote

Manages remote repositories.

List remotes:

bash
git remote -v

Add a new remote:

bash
git remote add origin https://github.com/user/repo.git

Rename a remote:

bash
git remote rename origin upstream

Final Tips

  • Use git status and git log often — they’re your safety net.
  • Don’t be afraid of branching and stashing — they help you experiment safely.
  • Always write meaningful commit messages.

Learning these 15 commands gives you a strong foundation for working with Git in most real-world scenarios.