Git Tutorial

Git Tutorial for Beginners

This Git tutorial explains the practical basics of Git: repositories, commits, branches, staging, remotes, and the commands beginners use most often. Git is a free and open source distributed version control system that records file changes and helps developers work safely on project history.

For a beginner, the main goal is not to memorize every Git command. The main goal is to understand how changes move from your working directory to the staging area, then into a commit, and finally to a remote repository when you share your work.

What Git Does in a Project

Git stores snapshots of your project as commits. Each commit has an identifier, an author, a date, and a message. This makes it possible to compare versions, review past work, create separate branches, and recover from mistakes.

• Track changes in source code and text-based project files.
• Save meaningful versions of a project as commits.
• Create branches for features, fixes, or experiments.
• Merge completed work back into another branch.
• Share commits through a remote repository.

Git and GitHub Difference for Beginners

Git and GitHub are related, but they are not the same. Git is the version control tool installed on your computer. GitHub is an online service that hosts Git repositories and adds collaboration features such as pull requests, issues, and project permissions.

Term	Meaning
Git	The version control system used to track project history.
GitHub	A hosting platform for Git repositories.
Local repository	The repository stored on your computer.
Remote repository	A repository stored on a server or hosting platform.

How Git Works: Working Directory, Staging Area, and Repository

Git beginners should first understand the three common areas in a local Git workflow.

Git area	What it means	Useful command
Working directory	The project files you are editing.	git status
Staging area	The selected changes for the next commit.	git add
Local repository	The committed history stored by Git.	git commit

Working directory  →  Staging area  →  Local repository  →  Remote repository
edit files             git add          git commit            git push

Check Git Installation and Configure Your Identity

After installing Git, check whether the command is available from your terminal or command prompt.

git --version

git version 2.45.0

Then configure the name and email address Git should attach to your commits.

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

Official command details are available in the Git tutorial from git-scm.com and the Git documentation.

Create or Clone a Git Repository

Use git init when you want to start Git tracking in a project folder. Use git clone when the repository already exists on a remote server.

mkdir my-project
cd my-project
git init

git clone https://example.com/user/project.git

A new Git repository contains a hidden .git directory. That directory stores repository metadata and local history, so do not delete it unless you intentionally want to remove Git tracking from that local copy.

Use git status Before Every Important Step

The git status command shows untracked, modified, staged, and committed changes. It is one of the safest commands to run while learning Git because it explains the current state of the repository.

git status

When you are unsure what to do next, run git status first. It helps you avoid staging or committing the wrong files.

Stage and Commit Changes in Git

Staging means selecting the changes that should go into the next commit. You can stage one file, multiple files, or all current changes.

git add filename
git add file1 file2
git add .

After staging the right files, save them as a commit with a clear message.

git commit -m "Add homepage layout"

A useful commit message describes the change. For example, Add login validation is clearer than update.

View Git Commit History

Use git log to see previous commits. A short one-line format is often easier for beginners.

git log --oneline

a1b2c3d Add homepage layout
e4f5g6h Initial commit

Work with Git Branches and Merge Changes

A branch lets you work on a feature, fix, or experiment without changing the main line of development immediately. When the work is complete, you can merge the branch.

git branch
git switch -c feature-login
git switch main
git merge feature-login

If two branches changed the same lines in the same file, Git may report a merge conflict. Resolve the file manually, stage the resolved file, and commit the result.

Connect Git to a Remote Repository

A remote repository is a copy stored outside your computer. It may be hosted on GitHub, GitLab, Bitbucket, or an internal Git server. The common remote name origin is a convention for the main remote repository.

git remote add origin https://example.com/user/project.git
git remote -v

Use git push to upload local commits and git pull to bring remote changes into your current branch.

git push -u origin main
git pull

Common Git Commands for Beginners

Command	Use
git init	Create a repository in the current folder.
git clone	Copy an existing repository.
git status	Check current file state.
git add	Stage selected changes.
git commit	Save staged changes.
git log	View commit history.
git branch	List or manage branches.
git switch	Move between branches.
git merge	Combine branch changes.
git pull	Get remote changes.
git push	Send commits to a remote repository.

Beginner Git Workflow Example

The following workflow is enough for many small changes in a beginner project.

git status
git add index.html
git commit -m "Update homepage content"
git push

Before starting new work in a shared repository, use git pull so your local branch has the latest remote changes.

What to Learn After Basic Git Commands

After the basic workflow is clear, practise reading diffs, resolving small merge conflicts, and understanding branch history. Interactive practice from Learn Git Branching, structured notes from Atlassian Git tutorials, and the Microsoft Learn introduction to Git can help you strengthen these concepts.

Git Mistakes Beginners Should Avoid

• Using git add . without checking which files are being staged.
• Committing passwords, API keys, generated files, or temporary files.
• Writing unclear commit messages such as fix or changes.
• Working for a long time without making small logical commits.
• Deleting the .git folder without understanding that it removes Git tracking from the local copy.

How Difficult Is Git to Learn?

Git is not difficult to start, but it takes repeated practice to become comfortable. Beginners should first learn status, add, commit, log, branch, switch, pull, and push. Advanced commands such as rebase, cherry-pick, and reflog can be learned later.

The best way to learn Git is to use it in a small project. Make a change, check status, stage the change, commit it, create a branch, merge it, and repeat the workflow until the steps become familiar.

Git Tutorial QA Checklist

• Does the tutorial explain the working directory, staging area, local repository, and remote repository?
• Are beginner Git commands introduced in a practical order?
• Are command examples marked with language-bash and output examples marked with output?
• Does the article clearly distinguish Git from GitHub?
• Does the tutorial warn about staging unwanted files and committing secrets?

Git Tutorial FAQs

How does Git work for beginners?

Git tracks changes in a project folder. You edit files, stage selected changes with git add, save them with git commit, and share them with git push when a remote repository is connected.

What is the best way to learn Git?

The best way to learn Git is to practise in a small project. Use git status often, make small commits, create a branch, merge it back, and then try pushing the repository to a remote service.

How long does it take to learn basic Git?

Basic Git can be learned in stages. A beginner can understand the common workflow after practising the core commands, but confidence with branches, conflicts, and team workflows usually comes through repeated use in real projects.

Is Git only for programmers?

No. Git is most common in software development, but it can also track many text-based projects such as documentation, scripts, configuration files, and technical writing.

Should I learn Git before GitHub?

Yes, it is helpful to learn the basic Git workflow first. GitHub becomes easier when you understand local commits, branches, pushes, pulls, and remote repositories.