Getting Started with
Git & GitHub

GitHub is the online platform where your code is stored and shared. You will need a free account before doing anything else.

Git is the version control software that runs on your computer. You need to install it before VS Code can use it.

git --version

git --version

In this step you will tell Git who you are, and then set up a secure SSH connection so that your computer can communicate with GitHub without requiring a password each time.

Git attaches your name and email to every change you save. This is how your contributions are recorded on GitHub.

Open the terminal in VS Code (Ctrl + `) and run these two commands. Replace the placeholder text with your actual details.

git config --global user.name  "Your Name"
git config --global user.email "[email protected]"

Verify that both values were saved correctly:

git config --list

You should see user.name and user.email listed in the output.

SSH is a secure method that lets your computer communicate with GitHub without entering your password every time you upload or download code. You will create a key pair: a private key that stays on your computer, and a public key that you give to GitHub.

ssh-keygen -t ed25519 -C "[email protected]"

cat ~/.ssh/id_ed25519.pub | clip

pbcopy < ~/.ssh/id_ed25519.pub

ssh -T [email protected]

Hi your-username! You've successfully authenticated, but GitHub does not provide shell access.

VS Code has basic Git support built in, but the following extensions make it significantly easier to work with GitHub. Think of extensions as add-ons that give VS Code extra abilities.

How to Install an Extension

The terminal (also called the command line) lets you control your computer by typing commands. Before you start working with Git, it helps to know a few basic commands for moving between folders and checking where you are.

Navigating Folders

When you open a terminal, you always start in a specific location on your computer — like standing inside a particular folder. These commands help you move around.

Navigating to a Folder — Worked Example

Suppose you want to save a project inside a folder called Projects on your Desktop. Here is how you would get there:

# Step 1: Check where you currently are
pwd

# Step 2: Move to the Desktop
cd C:\Users\YourName\Desktop

# Step 3: See what folders exist on the Desktop
dir

# Step 4: Move into your Projects folder
cd Projects

# Step 1: Check where you currently are
pwd

# Step 2: Move to the Desktop
# The tilde (~) is a shortcut that means "my home folder"
cd ~/Desktop

# Step 3: See what folders exist on the Desktop
ls

# Step 4: Move into your Projects folder
cd Projects

Opening a Folder in VS Code from the Terminal

Once you have navigated to a folder, you can open it directly in VS Code with a single command:

# The dot ( . ) means "the folder I am currently in"
code .

A repository (or "repo") is a folder where Git tracks all changes to your project. There are two ways to create one.

[email protected]:your-username/your-repo-name.git

git clone [email protected]:your-username/your-repo-name.git

# Stage all your changed files, ready to be saved
git add .

# Save a snapshot of your project with a descriptive message
git commit -m "Describe what you changed"

# Upload your latest commits to GitHub
git push

Before saving your work, it helps to understand how Git thinks about the files in your project. Git puts every file into one of three states at any given time.

The Three States Explained

Checking the Status of Your Files

At any time, you can run this command in the terminal to see which files are untracked, modified, or staged:

git status

Once you have made changes to your project, there are three actions you will perform regularly: stage your files, commit them with a message, and push them to GitHub. You can do all of this either through VS Code's Source Control panel or the terminal.

# 1. Stage all changed files
git add .

# 1b. To stage a specific file only:
git add filename.py

# 2. Commit with a message
git commit -m "Add player movement function"

# 3. Push to GitHub
git push

git pull

One of the most useful things about Git is that you can always go back. There are three different situations you might find yourself in, each with a different solution.

You have made changes to a file but have not committed them yet, and you want to throw those changes away and restore the file to how it was in the last commit.

# Discard changes in a specific file
git restore filename.py

# Discard ALL uncommitted changes in the entire project
git restore .

You have committed your changes but have not pushed them to GitHub yet, and you want to undo that commit. Your file edits are kept — only the commit is undone.

# Undo the last commit; your changes remain in the working directory
git reset --soft HEAD~1

You have already pushed a commit to GitHub and want to undo it. Because others may have already pulled your changes, you should not rewrite history — instead, use git revert, which creates a new commit that undoes the previous one safely.

git log --oneline

git revert a3f9c12

When you create a repository, Git creates a default timeline for your project called main. Every commit you make goes onto this timeline in order. Branches let you create a parallel copy of that timeline so you can experiment or add features without affecting the main version.

A Visual Example

Imagine you are building a game. Your main branch has the working game. You create a branch called add-scoreboard to build a new feature. While you work on it, main stays untouched. When the scoreboard is ready, you merge it in.

You can create and switch between branches either from VS Code or the terminal. When you create a branch, Git takes a copy of the current state of your project and gives that copy a new name.

# Create a new branch and switch to it immediately
git checkout -b add-scoreboard

# Check which branch you are currently on
git branch

# Switch to a different branch that already exists
git checkout main

# After committing, push the new branch to GitHub
git push --set-upstream origin add-scoreboard

Once your work on a branch is complete, the next step is to merge it back into main. On GitHub, this is done through a Pull Request (PR) — a proposal to merge your branch that can be reviewed and discussed before it is accepted.

git checkout main
git pull

If you merged something that broke the project, you can revert the merge commit on GitHub directly, or use the terminal.

# Revert a merge commit — the -m 1 flag tells Git to keep the main branch side
git revert -m 1 <merge-commit-id>
git push

GitHub is built for teamwork. When multiple people work on the same repository, a few extra concepts and habits become important.

When working with teammates, everyone follows the same pattern to avoid overwriting each other's work:

git checkout main
git pull

git checkout -b your-feature
# ... make changes, stage, commit ...
git push

A merge conflict happens when two people edit the same part of the same file. Git does not know which version to keep, so it asks you to decide.

<<<<<<< HEAD
score = 0          ← your version
=======
score = 10         ← teammate's version
>>>>>>> main

git add .
git commit -m "Resolve merge conflict in score.py"
git push

You may encounter these two terms when working with other people's repositories on GitHub.