Banko Stoyanov
In the world of software development, writing code is only part of the journey. Managing changes, collaborating with other developers, and keeping projects organized are just as important. This is where Git comes in.
Whether you’re taking your first steps into programming or looking to strengthen your development workflow, learning Git is one of the most valuable skills you can acquire. It helps you track changes, experiment with new ideas, recover from mistakes, and collaborate with confidence.
The good news? You don’t need to master hundreds of commands to get started. A handful of essential Git commands can transform the way you work.
Let’s explore the basics every developer should know.
1. What Is Git, and Why Does It Matter?
Git is a distributed version control system that records changes to files over time. Think of it as a detailed history of your project, allowing you to see what changed, when it changed, and who made the change.
Imagine working on a website and accidentally deleting an important section of code. Without version control, recovering your work might be difficult. With Git, you can inspect previous versions and restore the parts you need.
Git is especially useful because it allows you to:
- Track changes throughout a project.
- Return to previous versions when something goes wrong.
- Work on new features without disrupting existing code.
- Collaborate with other developers.
- Share projects through platforms such as GitHub, GitLab, and Bitbucket.
In short, Git gives you control over your code and confidence in your workflow.
2. Configure Git Before You Begin
Before creating your first commit, configure your identity. Git uses this information to associate commits with their authors.
Set your username
git config --global user.name "FirstName LastName"
Set your email address
git config --global user.email "you@example.com"
Choose your preferred output color
git config --global color.ui true
Check your configuration
git config --list
The --global option applies these settings to your user account across your local repositories. If necessary, you can override them for an individual project.
Pro tip: Use an appropriate email address for your development workflow. If you contribute to public repositories, consider using your hosting platform’s privacy-protected email option.
3. Create a Repository and Check Its Status
A Git repository is where Git tracks your project’s history.
To start tracking a project, navigate to its directory in your terminal and run:
git init
This initializes a Git repository in the current directory.
Next, check the state of your project:
git status
This command is one of the most useful tools in Git. It tells you which files are untracked, which have been modified, and which are staged for the next commit.
Make git status a habit. Running it regularly helps you understand exactly what Git is tracking before you make changes permanent.
4. Stage Your Files Before Committing
Git uses a staging area to let you choose which changes should be included in your next commit.
Stage a single file
git add index.html
Stage several specific files
git add index.html style.css script.js
Stage all changes in the current directory
git add .
The staging area is an important part of Git’s workflow. It allows you to group related changes together instead of committing everything at once.
For example, if you update a website’s navigation and fix an unrelated spelling mistake, you can stage and commit those changes separately.
Best practice: Review your changes with git status and, when appropriate, git diff --staged before committing. This helps prevent accidental additions of temporary files, credentials, or unrelated changes.
5. Remove Files from Tracking or Undo Changes Carefully
Sometimes you stage a file by mistake or decide that a file should no longer be tracked.
To remove a file from Git’s index while keeping the local file on disk, use:
git rm --cached filename.txt
This is useful when a file was accidentally added to version control and should remain on your computer.
To unstage a file while keeping your changes, use:
git restore --staged filename.txt
To discard unstaged changes in a tracked file, use:
git restore filename.txt
Be careful with the last command: it discards your uncommitted changes to that file.
Git also provides reset commands, but their effects depend on the options used. Before running an unfamiliar command, check its documentation and make sure you understand which changes may be affected.
6. Commit Your Changes and Build a Clear History
A commit is a snapshot of your project at a particular point in time. Commits allow you to understand how your project evolved and return to earlier states when necessary.
To create a commit, run:
git commit -m "Add responsive navigation"
The message should briefly explain what the commit accomplishes.
For example:
git commit -m "Fix login form validation"
Or:
git commit -m "Update homepage layout"
A useful commit message describes the change rather than simply stating that something happened.
Avoid vague messages such as changes, update, or fixed stuff. Clear messages make your project history much easier to understand, especially when working with a team.
What if you need to amend your last commit?
If you need to adjust the most recent commit, you can use:
git commit --amend -m "Improve login form validation"
Use this carefully, particularly if the original commit has already been shared with others. Amending changes the commit’s identity and can complicate collaborative workflows.
7. Connect Git to a Remote Repository
Git works locally, but remote repositories make it easier to back up projects and collaborate with others.
A remote is a reference to another repository, commonly hosted on a service such as GitHub or GitLab.
Add a remote repository
git remote add origin https://example.com/your-project.git
Replace the example URL with your actual repository URL.
Push your work to a remote repository
git push -u origin main
The -u option sets the upstream branch, making future pushes from that branch easier.
Note that the branch name may differ in your project. Many repositories use main, while older projects may use master.
Clone an existing repository
git clone https://example.com/your-project.git
Cloning creates a local copy of a remote repository, including its available history.
Pull updates from the remote repository
git pull
This fetches remote changes and integrates them into your current branch according to the configured behavior.
Before pulling, make sure you understand the state of your local changes. If you and another developer modify the same part of a file, Git may report a merge conflict that needs to be resolved.
8. Use Branches to Work More Safely
One of Git’s greatest strengths is branching. A branch lets you develop a feature, test an idea, or fix a bug without immediately changing your main development line.
List your branches
git branch
Create a new branch
git branch feature-login
Switch to an existing branch
git switch feature-login
Create and switch to a new branch
git switch -c feature-login
Merge a branch into your current branch
git merge feature-login
Before merging, switch to the branch that should receive the changes. For example, if your team merges completed features into main, switch to main before running the merge command.
Why branching matters
Imagine you’re maintaining an online store and need to introduce a new checkout process. Instead of experimenting directly on the main branch, you can create a feature branch, develop and test the changes, and merge them when they’re ready.
This keeps development organized and reduces the risk of disrupting existing functionality.
Pro tip: Use descriptive branch names such as feature/user-profile, fix/payment-error, or docs/setup-guide.
9. A Simple Git Workflow You Can Use Every Day
Knowing individual commands is useful, but understanding how they fit together is even more important.
Here’s a practical workflow for a typical coding session:
# 1. Check the current state
git status
# 2. Create a branch for your task
git switch -c feature/new-header
# 3. Stage the changes you want to include
git add index.html style.css
# 4. Review the staged changes
git diff --staged
# 5. Commit the changes
git commit -m "Add new website header"
# 6. Push the branch to the remote repository
git push -u origin feature/new-header
After pushing, you can open a pull request or merge request on your hosting platform so your team can review the code before it becomes part of the main branch.
If the branch already exists, switch to it instead of creating it again. Likewise, if your project has no remote configured, set one up before attempting to push.
The key principle is simple: check, stage, review, commit, and share.
10. Common Git Mistakes Beginners Should Avoid
Even experienced developers make mistakes with Git. The difference is learning how to prevent them and recover safely.
Here are a few habits worth developing early:
Committing everything without checking: Always inspect the staged changes before creating a commit.
Writing unclear commit messages: A readable history saves time when investigating bugs or reviewing changes.
Working directly on the main branch: Feature branches provide a safer place to experiment and develop new functionality.
Forgetting to pull or fetch updates: Keeping up with remote changes can reduce integration problems.
Using destructive commands without understanding them: Commands such as git reset --hard can permanently discard uncommitted work. Never run them casually.
Committing sensitive information: Passwords, access tokens, private keys, and environment files containing secrets should not be committed. Use a suitable .gitignore file and secure configuration methods. Remember that adding a file to .gitignore does not automatically untrack it if Git already tracks it.
The best Git habit is not memorizing every command. It is understanding what each command changes before you execute it.
11. Your Essential Git Command Cheat Sheet
Keep these commands handy as you build your Git skills.
| Command | What it does |
|---|---|
git init |
Initializes a repository |
git status |
Shows the current working-tree state |
git add filename |
Stages a specific file |
git add . |
Stages changes under the current directory |
git diff |
Shows unstaged changes |
git diff --staged |
Shows staged changes |
git commit -m "message" |
Creates a commit |
git log --oneline |
Displays a compact commit history |
git clone URL |
Copies a remote repository locally |
git pull |
Fetches and integrates remote changes |
git push |
Sends local commits to a remote |
git branch |
Lists local branches |
git switch -c name |
Creates and switches to a branch |
git merge name |
Merges a branch into the current branch |
git restore --staged file |
Unstages a file |
git rm --cached file |
Stops tracking a file but keeps it locally |
You don’t need to memorize this entire list today. Start with git status, git add, git commit, git switch, and git push. As your projects become more complex, you can gradually add more commands to your toolkit.
Final Thoughts: Make Git Part of Your Development Routine
Git is more than a collection of terminal commands. It is a way to work more confidently, organize your ideas, and collaborate effectively.
At first, version control may seem like another technical skill to learn. But once you understand the relationship between your working files, the staging area, commits, branches, and remote repositories, the workflow becomes much more intuitive.
Start with a small project. Make a few changes, commit them, create a branch, and experiment. Learn what happens when things go wrong, and practice recovering safely.
Every developer starts somewhere. The sooner you make Git part of your everyday routine, the sooner it becomes second nature.
Remember: good code matters, but knowing how to manage it is what helps you build, maintain, and improve software over time.
Ready to take the next step? Open your terminal, create your first repository, and make your first commit today.
Banko Stoyanov
