Git & GitHub Basics: A Beginner's Guide

What Is the Difference Between Git and GitHub?

This distinction is one of the first things to understand when learning version control.

You can use Git without GitHub. You can create commits, branches, and version history entirely on your own computer.

GitHub becomes useful when you want a remote copy of the repository or need features such as pull requests, issue tracking, code review, and collaboration.

What Is a Repository?

A repository, often shortened to repo, is the project being tracked by Git along with its version history and related Git information.

If you already have a project folder and want Git to start tracking it, you can initialize a repository.

git init

Before running the command, make sure your terminal is in the correct project folder. Accidentally initializing Git in the wrong directory can create confusion about which files belong to the repository.

Understand the Basic Git Workflow

At a beginner level, it helps to think about your files moving through a few stages.

This means saving a file in your code editor is not the same as creating a Git commit, and creating a local commit is not the same as uploading that commit to GitHub.

Check What Has Changed With git status

One of the most useful Git commands for beginners is:

git status

This command helps you see information such as which files have changed, which files are untracked, and which changes are staged for the next commit.

When you are unsure about the current state of your repository, git status is often a useful place to start.

Stage the Changes You Want to Commit

Git allows you to choose which changes should be included in the next commit.

To stage a particular file:

git add page.tsx

To stage changes under the current directory:

git add .

Create a Commit

A commit records a snapshot of the staged changes in the repository history.

git commit -m "Add contact page"

The message should briefly describe the purpose of the change. Compare these two messages:

Clear commit messages make the project history easier to understand later.

It is also usually easier to understand a history made of focused commits than one enormous commit containing several unrelated changes.

How Does a Local Repository Connect to GitHub?

A repository on your computer is local. A repository hosted elsewhere, such as on GitHub, can be configured as a remote.

A common remote name is origin.

git remote add origin <repository-url>

Replace <repository-url> with the appropriate remote repository URL.

You can inspect configured remotes with:

git remote -v

Authentication may be handled differently depending on whether you use HTTPS, SSH, a credential manager, or a development environment with GitHub integration.

Understand Clone, Pull, and Push

These commands are commonly used when working with remote Git repositories.

git clone <repository-url>

git pull

git push

What Is a Git Branch?

Branches allow development to proceed along separate lines without immediately changing another branch.

For example, you might create a branch for a new contact page while keeping the main branch unchanged until the work is ready.

git switch -c contact-page

To see your local branches:

git branch

To switch to an existing branch:

git switch main

Older tutorials may use git checkout for some branch operations. You may therefore encounter both commands while working with existing projects or documentation.

What Is a Pull Request?

A pull request is a GitHub collaboration feature used to propose changes from one branch for review and possible integration into another branch.

A common workflow might look like this:

Pull requests are particularly useful for team projects because they create a clear place to discuss and review proposed changes before integration.

Common Git & GitHub Mistakes

1. Assuming saving a file creates a commit

Saving updates the file on your computer. Git does not create a new commit until you stage the intended changes and commit them.

2. Assuming a commit automatically appears on GitHub

A local commit remains in your local repository until it is pushed to the appropriate remote branch.

3. Running commands without checking the current branch

Before committing, pulling, merging, or pushing, make sure you understand which branch you are currently working on.

4. Committing secrets

Passwords, private keys, API credentials, access tokens, and sensitive configuration should not be committed to a repository.

5. Committing unnecessary generated files

Dependencies, build output, temporary files, environment files, and editor-specific files may not belong in version control. A .gitignore file can tell Git which matching untracked files should normally be ignored.

6. Using unclear commit messages

Messages such as “stuff,” “changes,” or “final final” make the project history harder to understand. Describe the purpose of the change.

7. Using destructive commands without understanding them

Some Git operations can discard local changes or rewrite history. Do not copy a reset, clean, rebase, or force-push command simply because it appears in a troubleshooting answer. Understand its effect first.

Beginner Git Command Checklist

You do not need to memorize every Git command immediately. Start by understanding what these common commands do:

More important than memorizing commands is understanding the state of the repository before you run them.