You have just started learning to code. Things are going well. Then someone mentions Git and GitHub in a tutorial, a job description, or a developer community, and the conversation shifts into territory that feels unfamiliar.
What exactly is Git? Is it the same as GitHub? Do you need both? How does it all fit into your workflow as a developer?
These are the questions every beginner asks, and they deserve a clear, honest answer. Git and GitHub are two of the most important tools in software development. According to the 2024 Stack Overflow Developer Survey, over 97% of professional developers use Git as their version control system. That number alone tells you how essential this skill is, regardless of which programming language you use or what kind of software you want to build.
This guide walks you through everything from the ground up. What Git and GitHub are, why they matter, how to set them up, and every essential command you need to start using them with confidence today.
Git and GitHub Are Not the Same Thing
This is the most important clarification to make upfront, because the two terms are frequently used interchangeably even by people who should know better.
Git is a version control system that runs locally on your computer. It was created in 2005 by Linus Torvalds, the same person who created the Linux operating system. Git tracks every change you make to your files, remembers the full history of those changes, and allows you to go back to any previous version of your project at any point. Think of it as an extremely detailed undo history for your entire codebase.
GitHub is an online platform that hosts Git repositories in the cloud. It is owned by Microsoft and was founded in 2008. GitHub lets you store your Git projects online, share them with others, collaborate with teams, and contribute to open source projects. It adds a social and collaborative layer on top of Git.
A useful way to think about it: Git is the coffee, and GitHub is the coffee shop where that coffee is served. You can use Git entirely on your own computer without GitHub. But you cannot meaningfully use GitHub without Git.
There are other platforms that do what GitHub does, GitLab and Bitbucket being the most notable. But GitHub is by far the most widely used, with over 100 million developers on the platform as of 2025, making it the standard for portfolios, open source contributions, and professional collaboration.
Why Every Developer Needs Git
Before Git, developers managed code changes by saving multiple copies of files with names like “project_final.js,” “project_final_v2.js,” and “project_ACTUALLY_final.js.” Anyone who has been there knows how quickly that becomes unmanageable.
Git solves this completely. With Git, you never lose a version of your code. You can experiment freely on a separate branch without touching your working project. You can collaborate with a team of ten developers on the same codebase without overwriting each other’s work. And when something breaks, you can trace exactly what changed, when it changed, and who changed it.
For job seekers, a strong GitHub profile has become one of the most valuable things you can bring to an interview. Industry data from multiple hiring reports shows that a well-maintained GitHub profile increases hiring chances significantly, because it shows employers real work rather than just a list of claimed skills on a CV.
Setting Up Git and GitHub
Before you can use either tool, you need to install Git on your computer and create a GitHub account.
Installing Git:
- On Windows, download the Git installer from git-scm.com and run it. This also installs Git Bash, a terminal you can use to run Git commands.
- On Mac, open your terminal and type
git --version. If Git is not already installed, your Mac will prompt you to install it automatically through Xcode Command Line Tools. - On Linux (Ubuntu or Debian), open your terminal and run
sudo apt install git.
Once installed, verify it worked by opening your terminal and typing:
git --versionIf a version number appears, Git is ready.
Configuring Git for the first time:
Before you make your first commit, tell Git who you are. Run these two commands in your terminal, replacing the details with your own:
git config --global user.name "Your Name"
git config --global user.email "youremail@example.com"This information gets attached to every commit you make, so your contributions are properly attributed when working on team projects.
Creating a GitHub account: Go to github.com and sign up for a free account. Your username will be publicly visible, so choose something professional that you would be comfortable showing to an employer.
The Core Git Workflow: How It Actually Works
Git thinks about your project in three stages. Understanding these three stages is the key to understanding every Git command you will ever use.
The Working Directory is where you actually write and edit your files. Any changes you make here are tracked by Git but have not been saved to Git’s history yet.
The Staging Area is a holding zone where you prepare changes before saving them permanently. You choose exactly which changes go into the staging area before committing.
The Repository is where Git permanently stores your committed snapshots. Once something is committed, it is in Git’s history and can be retrieved at any time.
The flow goes: Working Directory to Staging Area to Repository. Files move through these three stages with the git add and git commit commands, which we will cover next.
Essential Git Commands Every Beginner Needs
These are the commands that cover the vast majority of what you will do with Git day to day. Learn these and you have everything you need to get started.
Start a new Git repository in your project folder:
git initRun this inside the folder where your project lives. It creates a hidden .git folder that tells Git to start tracking this directory.
Check what has changed:
git statusThis shows you which files have been modified, which are staged and ready to commit, and which are untracked. Run this constantly. It is your most used command in the early stages.
Stage your changes:
git add filename.jsTo stage every changed file at once:
git add .The . means “everything in this directory.” Use it carefully and intentionally.
Save your staged changes permanently:
git commit -m "Your clear, descriptive message here"A commit is a permanent snapshot of your staged changes. The message after -m should describe what changed and why. Good commit messages are short, specific, and written in the present tense. “Fix broken login button” is a good commit message. “changes” is not.
View your commit history:
git logThis shows every commit ever made in the repository, with the author, date, and message for each one. Press q to exit the log view.
Working With Branches
Branches are one of Git’s most powerful features, and they are worth understanding early.
A branch is a separate version of your codebase where you can make changes without affecting the main project. Think of the main branch as the official, stable version of your code. Every new feature, bug fix, or experiment lives on its own branch until it is ready to be merged back in.
Create and switch to a new branch:
git checkout -b feature-loginThis creates a branch called “feature-login” and switches you to it immediately.
Switch between branches:
git checkout mainMerge a branch back into main:
git checkout main
git merge feature-loginDelete a branch after merging:
git branch -d feature-loginBranching is what allows teams of dozens or hundreds of developers to work on the same project simultaneously without constantly conflicting with each other’s work. Even as a solo developer, the habit of working on branches keeps your main code clean and stable while you experiment.
Connecting Your Project to GitHub
Once you have commits in your local repository, you can push them to GitHub so they are backed up online and visible to others.
Create a new repository on GitHub: Log into GitHub, click the green “New” button on your dashboard, give your repository a name, and click “Create repository.” GitHub will show you a set of commands to connect your existing local repo to this new remote one.
Connect your local repo to GitHub:
git remote add origin https://github.com/your-username/your-repo-name.gitPush your code to GitHub:
git push -u origin mainThis uploads your local commits to GitHub. After this first push, you can use just git push for subsequent ones.
Pull changes from GitHub to your local machine:
git pull origin mainUse this when working in a team to fetch and merge any changes your teammates have pushed since you last synced.
Clone an existing GitHub repository to your computer:
git clone https://github.com/username/repository-name.gitCloning downloads the entire repository, including its full history, to your local machine. This is how you get started working on an existing project or contributing to open source.
The GitHub Interface: What You Actually Need to Know
Beyond storing code, GitHub has several features that are worth knowing from the start.
Repositories are the home of each project. Every repo has a README file, which is the first thing people see when they visit your project. Write a clear README for every project you share publicly.
Issues are GitHub’s task and bug-tracking system. On open source projects, issues are how maintainers communicate what needs to be done and how contributors signal they are working on something.
Pull Requests (PRs) are proposals to merge code from one branch into another. In team and open source workflows, a PR is how your work gets reviewed by others before it is merged into the main codebase. This is one of the most important collaboration features on GitHub and a concept you will use extensively once you start working with others.
GitHub Pages lets you host a static website directly from a GitHub repository for free. Many developers use it to publish their portfolio websites, project documentation, and personal blogs without paying for hosting.
Building a GitHub Profile Worth Showing
Your GitHub profile is a living portfolio. Recruiters and hiring managers check GitHub profiles regularly, and the signal a strong profile sends is significant.
A few habits that build a compelling profile over time: commit consistently rather than in infrequent bursts, write clear commit messages and readable READMEs, pin your best projects on your profile page so they are the first thing anyone sees, and contribute to open source where you can, as merged contributions to real projects carry significant weight.
The green contribution graph on your profile, which tracks daily commits, branches, and pull requests, is one of the first things people look at. Consistency matters more than volume. Regular small contributions over months are far more impressive than a single intense week of activity once a quarter.
A Quick Reference: Your Git Starter Commands
Here is a clean summary of the commands covered in this guide, in the order you are most likely to use them:
git init # Start a new repo
git status # Check what has changed
git add . # Stage all changes
git commit -m "message" # Save a snapshot
git log # View commit history
git checkout -b branch-name # Create and switch to a new branch
git checkout main # Switch back to main
git merge branch-name # Merge a branch into current branch
git remote add origin <url> # Connect to a GitHub repo
git push -u origin main # Push code to GitHub
git pull origin main # Pull latest changes from GitHub
git clone <url> # Clone a repo to your machineSave this. You will use these commands more than almost anything else in your development workflow.
Git and GitHub can feel overwhelming when you first encounter them, but the core concepts are simpler than they appear. Git tracks your code history. GitHub stores it online and enables collaboration. Branches let you work safely. Commits build a record of your progress. Pull requests open your work to review.
Start by running git init on your next project. Make commits regularly as you work. Push to GitHub so your work is backed up and visible. Over time, the workflow becomes second nature, and you will wonder how you ever wrote code without it.
Every developer working professionally today uses Git. The sooner you build the habit, the faster everything else in your development career accelerates.
Are you just getting started with Git, or is there a specific part of the workflow that still confuses you? Drop your question in the comments below. We would love to help from the TechCityNG community!