The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →You learn Git by mastering one repeating loop: check what has changed, choose which changes belong together, save them as a commit, and then read the history. Once that loop feels routine, branches, undoing mistakes, and remote hosting become manageable next steps instead of puzzles. This guide builds that loop with a small practice project, uses the command line as the teaching baseline, and shows where a graphical client fits.
What version control does and why Git is worth learning
Version control records how files change over time. It lets you return to an earlier version, compare two versions, or find out when and why something changed. Git is the version-control system most people learn first. It is built for source code, but it can track any files you keep in a folder, such as essays, configuration files, or research notes. Diffs are easiest to read for plain-text files, so a folder of text documents is an ideal place to start.
As an Amazon Associate I earn from qualifying purchases.
Git is not a backup service by itself. Its commits live in the repository on your own machine. A copy of that repository somewhere else, such as on a hosting site, is what gives you a second location, and that requires a remote, covered later in this guide.
The three areas you need to understand
Almost every Git command is easier to read once you know where a change currently sits. Git uses three areas:
#1 Best Overall
- Working tree. These are the ordinary files on disk that you edit in your editor or file manager.
- Staging area (also called the index). This is a holding area where you select the changes that will go into your next commit. Staging lets you split unrelated edits into separate commits.
- Commit. A commit saves a snapshot of what is in the staging area, along with a message and the author’s name and date.
Here is why the middle area matters. Suppose you edit three files but only two belong to one task. You stage those two, commit them, and the third file stays modified in the working tree for a separate commit later. Nothing is lost, and the history stays readable.
Install Git and set your identity
- Open the official Git installation page for your operating system from the official Git project website, and follow the instructions there. Installation methods and version numbers change, so the live page is the source to trust.
- On Windows, the official installation page lists a standalone installer, a portable option, and installation through winget. When this guide was checked in early October 2026, the page listed Git 2.56.0 as the latest release, dated 28 September 2026. The winget command shown on that page was
winget install --id Git.Git -e --source winget. Confirm the current version before following any version-specific step. - Open a terminal and run
git --version. A working installation prints a line beginning withgit versionfollowed by a version number. - Tell Git who you are. Every commit records this name and email address, so set them once:
git config --global user.name "Ada Lovelace" git config --global user.email "[email protected]"Use your own name and an email address you are comfortable publishing, because the values are stored inside each commit.
Installation pages for macOS and Linux differ from the Windows page, so follow the official instructions for your own system rather than copying commands from a different platform.
Start a repository: init versus clone
A repository is a project folder that Git tracks. You can begin in two different ways, and they lead to different starting states.
Free tools Windows power users keep installed
One-click scans. No signup required.
Rank #2
- Used Book in Good Condition
| Item | git init |
git clone <url> |
|---|---|---|
| Starting condition | A local folder that already holds your files | An existing repository available at a URL |
| What Git does | Creates a hidden .git folder that stores history inside the project |
Copies the repository and its history, then checks out a working copy |
| Result | A repository with no commits yet; your existing files are untracked until you add and commit them | A working copy with the existing history, ready to edit |
| Typical use | Starting a new project from scratch | Joining a project someone else already keeps in Git |
For the practice project in this guide, begin with init:
mkdir notes-practice
cd notes-practice
git init
echo "Buy coffee" > todo.txtRunning git init reports that it created an empty repository. The new file todo.txt exists in the working tree, but Git is not yet saving it in any commit.
The core loop: inspect, stage, commit, read history
Run these steps in order each time you finish a unit of work.
Rank #3
- Check the state. Run
git status. For the new file, it showstodo.txtunder “Untracked files,” which means Git sees it but has not been asked to track it. - Review the content. Run
git diffto see unstaged edits to files Git already tracks. It shows nothing for a brand-new untracked file, so usegit statusfor those. After you stage something,git diff --stagedshows what is ready for the next commit. - Stage deliberately. Run
git add todo.txt. Thengit statuslists the file under “Changes to be committed.” - Commit. Run
git commit -m "Add first todo list". The message should describe the change in a short phrase. If you leave out-m, Git opens your configured text editor so you can write the message. - Read the history. Run
git logto see each commit’s hash, author, date, and message. Rungit log --onelinefor a compact one-line view.
Now repeat the cycle. Add a second line to todo.txt, run git status and git diff, stage the file, commit with a new message, and run git log --oneline. You will see two commits, and the diff between them is exactly the line you added.
Why you should not default to git add .
Many tutorials show git add . as a habit. It stages every change in the folder, including files you did not mean to commit, such as temporary output, editor backup files, or a file containing a password. Use git status first, read the list, and then name the files you want. The extra few seconds are what keep each commit intentional.
Ignore files you should not track
Create a plain-text file named .gitignore in the repository’s top folder and list the names or patterns to exclude. For example, these lines ignore log files and a build folder:
Rank #4
*.log
build/Ignored files stop appearing as untracked in git status. A rule in .gitignore does not remove a file Git already tracks, so check git status after adding rules to an existing project.
Where to go after the basic loop
The basic loop is enough for solo work on a local project. Learn these skills in roughly this order, and practise each one on a disposable project before relying on it:
- Undoing mistakes. Git has several ways to discard or revise changes. Some of them can throw away work, so read the official Pro Git explanation of each command before using it on anything important.
- Branches. A branch is a separate line of commits, useful for trying an idea without disturbing your main work.
- Remotes. A remote is another copy of your repository, usually on a hosting service. Pushing sends your commits there, and pulling brings others’ commits down to you.
Git and hosting services are different things
Git is the version-control software on your computer. Hosting services are websites where repositories can be stored and shared, and GitHub is one example. The services work with Git but are not Git itself. You can learn the complete local workflow without creating an account anywhere. Adding a hosting site becomes useful once you want a remote copy or a way to share your project, and at that point you connect your local repository to the remote and use push and pull.
Best Value
Terminal or graphical interface?
Pro Git’s discussion of the command line says the terminal can run every Git command, while graphical clients may implement only a subset. It also describes the choice of interface as a matter of personal preference. The table below compares the two for a beginner.
| Comparison point | Command line | Graphical client |
|---|---|---|
| Visibility into Git’s actual state | Shows the exact commands you ran and the exact output Git printed | Shows state visually in panels and lists; the underlying commands may be hidden |
| Coverage of less-common commands | Can run all Git commands | May implement only some commands; check the client’s feature list |
| Following tutorials | Most written tutorials and official documentation use these commands directly | Menu names and buttons vary between clients, so steps must be translated |
| Comfort | Requires comfort with typing commands in a terminal | Often easier to see changes at a glance |
A reasonable path is to work through the loop in this guide with the terminal first, so you know what each step does. A graphical client can then make reviewing history easier, and the commands you already know will help when a feature is missing from the interface.
Learning resources from the official Git project
- Pro Git, free online. The official Git site offers the full Pro Git book free to read online. The book overview labels this as the second edition, published in 2014, so check whether newer material covers a command you need.
- Git Learn page. The official site also links short introductory videos, a cheat sheet, and external resources.
- Pro Git print edition (optional). The official site notes that print copies are available on Amazon. A printed Git reference is useful when you are offline, but you do not need to buy anything to learn Git.
The official Git user manual is written for readers with only basic command-line experience. In its own words, it is “designed to be readable by someone with basic UNIX command-line skills, but no previous knowledge of Git.” The Git Basics chapter of Pro Git says: “If you can read only one chapter to get going with Git, this is it.” That chapter is a good companion to this guide, but reading it does not replace running the commands yourself.
A modest practice plan
- Repeat the loop on a disposable project. Create a folder, run
git init, and make several commits over a few days. Usegit statusandgit diffbefore every commit. - Make a branch and merge it. Run
git switch -c experiment, make two commits, then rungit switchfollowed by the name of your main branch (commonlymainormaster, depending on your setup). Rungit merge experimentand read the history withgit log --oneline --graph. - Add a remote only after local commits make sense. When you can explain what each commit contains, connect the project to a hosting service and practise pushing and pulling there.
Work through these steps in order. Each one depends on the habit of reading status and history before you change anything.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
