Track a Project with Git and GitHub

Build a version-controlled recipe collection and publish it to GitHub.

Introduction

30 Second Summary

Every time you save a document and name it final_v2_FINAL_actual.docx, you're doing version control badly. Developers solved this problem decades ago with a tool that tracks every change, lets you undo mistakes, and makes collaboration seamless.

In this project, you will create a small recipe collection tracked with Git from the very first file, build a history of changes, work with branches, and publish it all to GitHub.

What You'll Build

A recipe collection project tracked with version control, featuring multiple commits, a merged feature branch, and a published GitHub repository.

By the end of this project, you'll have:

  • A local Git repository with at least 5 commits showing a clear history of changes.
  • A .gitignore file configured to keep unwanted files out of your project.
  • A merged feature branch demonstrating the branch-and-merge workflow developers use daily.
  • A public GitHub repository with your full commit history visible to the world.
  • Secret Mission: resolve a merge conflict by hand and prove you can handle the trickiest part of team collaboration.

Are there any prerequisites?

You should be comfortable opening a terminal and navigating directories (cd, ls, mkdir). No programming experience is needed.

Before We Start

Before We Start...

Install and Configure Git

Every project you work on as a developer relies on version control to track changes over time.

In this step, you'll install Git on your machine and configure it with your identity. This ensures every change you record is properly attributed to you.

In this step, get ready to:
  • Install Git and verify it works.
  • Configure your name and email for commits.
  • Set the default branch name to main.
Install Git

Git may already be installed on your Linux system. Let's check first before installing anything.

  • Check if Git is already installed by running this command:
git --version

You should see output in the format git version 2.x.x if Git is installed.

✔️ I see a version number

Git is already installed on your machine. Skip ahead to the next substep where you'll configure your identity.

ⓧ Command not found

Git is not installed yet. Install it using your Linux distribution's package manager.

Ubuntu / Debian

  • Install Git by running this command:
sudo apt-get install git

Fedora

  • Install Git by running this command:
sudo dnf install git

Arch Linux

  • Install Git by running this command:
sudo pacman -S git
  • After installation completes, verify Git is working by running:
git --version

You should now see git version followed by a number like 2.43.0 or higher.

Still seeing command not found?

Make sure the install command completed without errors. Look for any "permission denied" messages in the terminal output.

If you see a permissions error, make sure you included sudo at the start of the install command.

Help me troubleshoot my Git installation on Linux.

Configure your identity

Every commit you make in Git is stamped with your name and email address. You need to set these once so Git knows who you are.

  • Set your name for commits by running this command:
git config --global user.name "[[YOURNAME="Your Name"]]"
  • Set your email address for commits by running this command:
git config --global user.email "[[YOUREMAIL="your@email.com"]]"

What do these commands do?

The --global flag means these settings apply to every Git repository on your machine. You only need to run this once.

Your name and email show up in every commit you make. Use the same email you plan to use for your GitHub account so your commits are linked to your profile.

  • Confirm your settings are saved by running:
git config --global user.name
git config --global user.email

You should see your name printed on the first line and your email on the second.

Seeing blank output?

If nothing prints, the config was not saved. Re-run the two git config commands above and make sure you include the --global flag and wrap your name or email in quotes.

Help me figure out why my Git config settings are not saving.

Set the default branch name

When you create a new repository, Git names the first branch for you. GitHub uses main as the default, so you'll configure Git to match.

  • Set the default branch name to main by running this command:
git config --global init.defaultBranch main

Why set the default branch to main?

GitHub defaults to main for new repositories. Setting your local Git to use the same name avoids confusion when you push your work to GitHub later.

  • Confirm the setting is saved by running:
git config --global init.defaultBranch

You should see main printed in the terminal.

Your machine is now ready to track changes. Next up, you'll create your first repository and make your very first commit.

Create Your First Repository and Commit

Every Git project starts with a repository. A repository is a folder that Git watches for changes, tracking every edit you make so you can rewind, compare, or share your work.

In this step, you'll create a project folder, turn it into a Git repository, and make your first two commits. By the end, you'll have a working version-controlled project with a clean starting point.

In this step, get ready to:
  • Create a project directory and initialize a Git repository.
  • Create a README file and make your first commit.
  • Add a .gitignore file to keep unwanted files out of your repository.
Create the project directory and initialize Git

Before Git can track anything, you need a folder for your project and a one-time initialization command that tells Git to start watching it.

  • Move to your Desktop by running this command:
cd ~/Desktop
  • Create your project folder and move into it by running these commands:
mkdir recipe-book
cd recipe-book
  • Confirm you're in the right folder by running:
pwd

You should see a path ending in /Desktop/recipe-book.

  • Initialize a Git repository in this folder by running:
git init

What does this command do?

git init creates a hidden .git folder inside your project directory. This folder is where Git stores all of its tracking data.

You never need to touch anything inside .git directly. Git manages it for you every time you make a commit or create a branch.

  • Verify the repository was created by running:
ls -a

You should see a .git entry in the output. This confirms Git is now tracking this folder.

Don't see .git in the output?

Make sure you used ls -a (with the -a flag). Without it, hidden folders starting with a dot are not shown.

If you still don't see it, double-check that you ran git init while inside the recipe-book folder. Run pwd to confirm your location.

Help me troubleshoot why git init didn't create a .git folder in my recipe-book directory.

Create a README and make your first commit

A README.md file describes what your project is about. It's the first thing people see when they visit your repository, so it's the perfect file to start with.

  • Open a new file called README.md in the nano text editor by running:
nano README.md
  • Type or paste the following content into nano:
# Recipe Book

A collection of my favourite recipes, tracked with Git.

## Recipes

- [Guacamole](guacamole.md)
- [Chocolate Cake](chocolate-cake.md)
  • Save the file by pressing Ctrl+O, then press Enter to confirm the filename.
  • Exit nano by pressing Ctrl+X.

What does this file do?

README.md is written in Markdown, a lightweight formatting language that uses symbols like # for headings and - for bullet points.

The links to guacamole.md and chocolate-cake.md point to recipe files you'll create in later steps. The README acts as a table of contents for your project.

Now that the file exists, you need to tell Git about it. Git uses a two-step process: first you stage files (choose what to include), then you commit them (save a snapshot).

  • Stage the README file by running:
git add README.md
  • Check the staging area to see what Git is about to commit by running:
git status

You should see README.md listed in green under "Changes to be committed". This means the file is staged and ready to go.

What is the staging area?

The staging area is a holding zone between your working files and a commit. It lets you choose exactly which changes to include in your next snapshot.

Think of it like packing a box before shipping. You pick what goes in (git add), then seal and label it (git commit).

  • Make your first commit by running:
git commit -m "Add README with project description"

What does this command do?

git commit takes everything in the staging area and saves it as a permanent snapshot in your project's history.

The -m flag lets you attach a short message describing what you changed. Good commit messages start with a verb and summarize the change in under 50 characters.

You should see output confirming the commit, including the branch name (main) and a short summary of what was added.

Seeing an error about author identity?

If Git says it doesn't know who you are, your global config from the previous step might not have been saved. Re-run the git config --global user.name and git config --global user.email commands from Step 1, then try the commit again.

Help me fix an author identity error when trying to make my first git commit.

Add a .gitignore file

Some files should never be tracked by Git. Editor swap files, OS-generated junk, and environment files with secrets are all noise that clutters your repository.

  • Create a .gitignore file in nano by running:
nano .gitignore
  • Type or paste the following content into nano:
# Editor swap files
*.swp
*.swo
*~

# OS-generated files
.DS_Store
Thumbs.db

# Environment files
.env
  • Save the file by pressing Ctrl+O, then press Enter to confirm the filename.
  • Exit nano by pressing Ctrl+X.

What does .gitignore do?

Any file matching a pattern in .gitignore will be completely invisible to Git. It won't be staged, committed, or tracked.

The *.swp pattern uses a wildcard (*) to match any file ending in .swp. These are temporary files created by text editors like Vim while you edit.

  • Stage and commit the .gitignore file by running these commands:
git add .gitignore
git commit -m "Add .gitignore to exclude unwanted files"

You should see output confirming the commit on the main branch with 1 file changed.

  • Confirm both files are tracked by running:
ls -a

You should see .git, .gitignore, and README.md in the output.

Commit says 'nothing to commit'?

This means you ran git commit without staging the file first. Make sure you ran git add .gitignore before the commit command.

Run git status to check whether the file is staged (green) or untracked (red).

Help me figure out why git says nothing to commit when I'm trying to commit my .gitignore file.

✔️ Awesome, I've got everything!

Great. You now have two commits on your main branch and a solid project foundation.

ⓧ I'd like to double check the full code

Here's what your README.md should look like:

# Recipe Book

A collection of my favourite recipes, tracked with Git.

## Recipes

- [Guacamole](guacamole.md)
- [Chocolate Cake](chocolate-cake.md)

Here's what your .gitignore should look like:

# Editor swap files
*.swp
*.swo
*~

# OS-generated files
.DS_Store
Thumbs.db

# Environment files
.env

Your repository is alive. You've got a clean starting point with two meaningful commits. Next up, you'll add recipe files and build a real commit history that tells the story of your project evolving over time.

Build a Commit History

Your repository is initialized and you have two commits under your belt. Now it's time to see what makes version control truly powerful: a meaningful commit history.

Each commit is a snapshot of your project at a specific moment. When you string multiple commits together, you get a timeline that tells the story of how your project evolved. In this step, you'll build that timeline by adding a recipe, modifying it, and inspecting the history.

In this step, get ready to:
  • Create a recipe file and commit it to your repository.
  • Modify the recipe, inspect the change with git diff, and commit the update.
  • Review your full commit history with git log.
Create your first recipe file

Every good recipe book needs at least one recipe. You'll create a guacamole recipe as a Markdown file and commit it to your repository.

  • Create guacamole.md by running this command:
cat > guacamole.md << 'EOF'
# Guacamole

A simple and delicious guacamole recipe.

## Ingredients

- 3 ripe avocados
- 1 lime, juiced
- 1 teaspoon salt
- 1/2 cup diced onion
- 3 tablespoons fresh cilantro, chopped
- 2 roma tomatoes, diced
- 1 teaspoon minced garlic

## Instructions

1. Cut avocados in half and remove the pit. Scoop out the flesh into a bowl.
2. Mash the avocado with a fork until it reaches your desired consistency.
3. Stir in lime juice and salt.
4. Mix in onion, cilantro, tomatoes, and garlic.
5. Add cayenne pepper to taste.
6. Refrigerate for 1 hour for best flavour, or serve immediately.
EOF

What does this command do?

The cat > guacamole.md << 'EOF' syntax is called a heredoc. It creates a file and writes everything between the two EOF markers into it. This lets you create a multi-line file in a single terminal command.

  • Confirm the file was created by running:
ls

You should see guacamole.md listed alongside README.md and .gitignore.

  • Stage the new file and commit it by running these commands:
git add guacamole.md
git commit -m "Add guacamole recipe"

What does this do?

git add guacamole.md moves the file into the staging area, telling Git you want to include it in the next commit.

git commit -m "Add guacamole recipe" saves that snapshot permanently with a descriptive message. Good commit messages start with a verb and summarize what changed.

You should see output confirming the commit was created, including the number of lines added.

Seeing 'nothing to commit'?

Make sure you ran the cat > guacamole.md << 'EOF' command first. If the file wasn't created, the git add has nothing to stage.

Run ls to check that guacamole.md exists in your current directory.

help me debug why my git commit says nothing to commit

Modify the recipe and inspect the change

The instructions mention cayenne pepper, but the ingredients list is missing it. You'll fix that oversight and learn how to see exactly what changed before committing.

  • Open guacamole.md in a text editor by running:
nano guacamole.md
  • Find the line that says - 1 teaspoon minced garlic.
  • Add a new line directly below it with this text:
- 1 pinch ground cayenne pepper
  • Save the file by pressing Ctrl+O then Enter, and exit nano by pressing Ctrl+X.

Use any text editor you prefer

If you prefer vim or another editor, feel free to use it. The important thing is that the line - 1 pinch ground cayenne pepper appears after the garlic ingredient.

  • See exactly what changed by running:
git diff

What does git diff show you?

git diff shows the difference between your working directory and the last commit. Lines prefixed with + are additions. Lines prefixed with - are deletions.

You should see your new cayenne pepper line marked with a + at the beginning. This is how developers review changes before committing them.

  • Stage and commit the update by running:
git add guacamole.md
git commit -m "Update guacamole recipe with extra ingredient"

You should see output confirming one file changed with one insertion.

Diff shows nothing?

If git diff shows no output, you may have already staged the file with git add. Try git diff --staged to see staged changes instead.

If neither shows anything, re-open guacamole.md and confirm the cayenne pepper line was saved.

help me figure out why git diff is not showing my changes

✔️ Awesome, I've got everything!

Great. Double check you saved your file after the edit.

ⓧ I'd like to double check the full code

Here is the complete guacamole.md after both commits:

# Guacamole

A simple and delicious guacamole recipe.

## Ingredients

- 3 ripe avocados
- 1 lime, juiced
- 1 teaspoon salt
- 1/2 cup diced onion
- 3 tablespoons fresh cilantro, chopped
- 2 roma tomatoes, diced
- 1 teaspoon minced garlic
- 1 pinch ground cayenne pepper

## Instructions

1. Cut avocados in half and remove the pit. Scoop out the flesh into a bowl.
2. Mash the avocado with a fork until it reaches your desired consistency.
3. Stir in lime juice and salt.
4. Mix in onion, cilantro, tomatoes, and garlic.
5. Add cayenne pepper to taste.
6. Refrigerate for 1 hour for best flavour, or serve immediately.
Review your commit history

You've made four commits now. Git keeps a log of every single one, forming a complete timeline of your project.

  • View your full commit history by running:
git log

What does git log show you?

Each entry in the log shows a unique commit hash, the author name and email you configured earlier, the date, and the commit message.

The commits appear in reverse chronological order. Your most recent commit (Update guacamole recipe with extra ingredient) is at the top. Your first commit (Add README with project description) is at the bottom.

Press q to exit the log view if it fills more than one screen.

Log looks different than expected?

If you see fewer than four commits, one of your earlier git commit commands may not have run successfully. Check the messages in your terminal history for any errors.

help me understand why my git log is showing fewer commits than expected

You now have a repository with a real history. Next up, you'll learn how to work on new features without touching your main branch.

Work with Branches

Your recipe book now has a clear commit history showing every change you made. But real projects rarely move in a straight line. You often want to experiment with a new idea without risking the stable version of your work.

That is exactly what branches solve. A branch lets you work on something new in isolation, then bring it back into the main project when it is ready. In this step, you will create a branch, add a new recipe on it, and merge it back into main.

In this step, get ready to:
  • Create a new branch and switch to it.
  • Add a new recipe file on the branch and commit it.
  • Merge the branch back into main and clean it up.
Create and switch to a new branch

Right now, all your commits live on the main branch. You want to add a dessert recipe, but you would like to keep that work separate until you are happy with it.

  • Create a new branch called add-dessert and switch to it by running this command:
git switch -c add-dessert

What does this command do?

The git switch -c command does two things at once. It creates a new branch with the name you provide, then immediately switches your working directory to that branch. Every commit you make from here lands on add-dessert instead of main.

You should see the message Switched to a new branch 'add-dessert' confirming the switch.

Don't see that message?

Make sure you typed the command exactly as shown, including the -c flag. Without -c, Git tries to switch to an existing branch and fails because add-dessert does not exist yet.

help me fix a git switch error

Add a recipe on the new branch

You are now on the add-dessert branch. Any new files you create and commit here will not appear on main until you merge them.

  • Open a new file called chocolate-cake.md in nano by running:
nano chocolate-cake.md
  • Paste the following recipe content into the editor:
# Chocolate Cake

A rich and moist chocolate cake for any occasion.

## Ingredients

- 2 cups all-purpose flour
- 2 cups sugar
- 3/4 cup unsweetened cocoa powder
- 2 teaspoons baking soda
- 1 teaspoon salt
- 2 eggs
- 1 cup buttermilk
- 1 cup hot water
- 1/2 cup vegetable oil
- 2 teaspoons vanilla extract

## Instructions

1. Preheat oven to 175°C (350°F). Grease and flour two 9-inch round baking pans.
2. Combine flour, sugar, cocoa, baking soda, and salt in a large bowl.
3. Add eggs, buttermilk, oil, and vanilla. Beat with a mixer on medium speed for 2 minutes.
4. Stir in hot water (batter will be thin, this is normal).
5. Pour batter evenly into prepared pans.
6. Bake for 30-35 minutes, or until a toothpick inserted in the centre comes out clean.
7. Cool in pans for 10 minutes, then transfer to a wire rack to cool completely.
  • Save the file by pressing Ctrl+O, then press Enter to confirm the filename.
  • Exit nano by pressing Ctrl+X.

What does this file contain?

You just created a chocolate cake recipe with an ingredients list and numbered instructions. The file uses Markdown headings and lists, just like your other recipe files.

  • Stage and commit the new recipe by running these commands:
git add chocolate-cake.md
git commit -m "Add chocolate cake recipe"

What does this do?

The git add command stages your new file, and git commit records it as a snapshot on the add-dessert branch. The main branch still has no knowledge of this file.

  • Confirm the commit was recorded by running:
git log --oneline

You should see your new commit at the top of the log, with HEAD -> add-dessert next to it.

Don't see the new commit?

Make sure you ran both git add and git commit. If you only ran git add, the file is staged but not committed. Run the git commit command to finish.

help me fix my git commit

✔️ Awesome, I've got everything!

Great. Double check you saved the file and the commit appears in your log.

ⓧ I'd like to double check the full code

Here is the complete chocolate-cake.md file for comparison:

# Chocolate Cake

A rich and moist chocolate cake for any occasion.

## Ingredients

- 2 cups all-purpose flour
- 2 cups sugar
- 3/4 cup unsweetened cocoa powder
- 2 teaspoons baking soda
- 1 teaspoon salt
- 2 eggs
- 1 cup buttermilk
- 1 cup hot water
- 1/2 cup vegetable oil
- 2 teaspoons vanilla extract

## Instructions

1. Preheat oven to 175°C (350°F). Grease and flour two 9-inch round baking pans.
2. Combine flour, sugar, cocoa, baking soda, and salt in a large bowl.
3. Add eggs, buttermilk, oil, and vanilla. Beat with a mixer on medium speed for 2 minutes.
4. Stir in hot water (batter will be thin, this is normal).
5. Pour batter evenly into prepared pans.
6. Bake for 30-35 minutes, or until a toothpick inserted in the centre comes out clean.
7. Cool in pans for 10 minutes, then transfer to a wire rack to cool completely.
Merge the branch and clean up

Your dessert recipe is ready. Now you want to bring it back into the main branch so it becomes part of the official project.

  • Switch back to the main branch by running:
git switch main
  • Confirm that chocolate-cake.md is not here yet by running:
ls

You should only see README.md, .gitignore, and guacamole.md. The chocolate cake file only exists on the add-dessert branch.

Why is the file missing?

Each branch has its own view of the project. When you switch branches, Git updates your working directory to match that branch's latest commit. Since main never received the chocolate cake commit, the file is not visible here.

  • Merge the add-dessert branch into main by running:
git merge add-dessert

What does merging do?

Merging takes the commits from another branch and applies them to your current branch. After this command, main now includes the chocolate cake commit you made on add-dessert.

Since main had no new commits while you were on add-dessert, Git performs a fast-forward merge. It simply moves the main pointer forward to include the new commit.

  • Verify that chocolate-cake.md now appears on main by running:
ls

You should now see chocolate-cake.md listed alongside your other files.

  • Delete the add-dessert branch since its work has been merged by running:
git branch -d add-dessert

You should see a confirmation message: Deleted branch add-dessert followed by the commit hash it pointed to.

Why delete the branch?

Deleting a merged branch is housekeeping. The commits are safely on main now, so the branch label is no longer needed. The -d flag only works if the branch is fully merged, so Git protects you from accidentally losing work.

Getting an error when deleting?

If you see a message saying the branch is not fully merged, make sure you ran git merge add-dessert first. The delete command only works after a successful merge.

help me delete my git branch

Your repository now has a complete branch-and-merge cycle under its belt. Next up, you will push all of this work to GitHub so it is backed up online and visible to collaborators.

Push to GitHub

Your recipe book has a solid local history with commits, branches, and merges. Right now, all of that work lives only on your machine.

In this step, you'll publish your repository to GitHub, a cloud platform that hosts Git repositories. Once your code is on GitHub, it's backed up, shareable, and ready for collaboration.

In this step, get ready to:
  • Create a new empty repository on GitHub.
  • Connect your local repository to GitHub and push your commits.
  • Verify your files and commit history are visible on GitHub.
Create a new repository on GitHub

GitHub needs an empty repository to receive your local commits. You'll create one through the GitHub website with no pre-populated files.

  • Open your web browser and go to https://github.com.
  • Sign in to your GitHub account. If you don't have one yet, click Sign up and follow the prompts to create a free account.
  • Once signed in, navigate to https://github.com/new to open the new repository page.
  • In the Repository name field, type recipe-book.
  • Under visibility, select Public.
  • Leave all initialization options unchecked. Do not add a README, .gitignore, or license.
  • Click Create repository.

Why leave the repository empty?

You already have a README and .gitignore in your local repository. If GitHub also creates these files, you'll get a conflict when you try to push. Starting with an empty repository avoids this problem entirely.

After clicking Create repository, GitHub shows a Quick Setup page with your repository URL. You'll need this URL in the next substep.

  • On the Quick Setup page, make sure HTTPS is selected (not SSH).
  • Copy the repository URL displayed on the page. It looks like https://github.com/your-username/recipe-book.git.

Don't see the Quick Setup page?

If you accidentally initialized the repository with a README or other files, delete the repository and create it again. Go to Settings at the bottom of the repository page, scroll to the Danger Zone, and click Delete this repository.

help me delete and recreate my GitHub repository

Connect your local repository and push

With the empty GitHub repository ready, you'll now link it to your local repository and upload all your commits in one command.

  • Switch back to your terminal (you should still be inside the recipe-book folder).
  • Connect your local repository to GitHub by running this command:
git remote add origin [[REPO_URL="https://github.com/your-username/recipe-book.git"]]

What does this command do?

This tells Git that a remote repository exists at the URL you provided. The name origin is the conventional nickname for your primary remote repository.

You can think of it like saving a bookmark. Git now knows where to send your commits when you push.

  • Push all your commits to GitHub by running:
git push -u origin main

What does this command do?

This uploads every commit on your main branch to the origin remote. The -u flag sets origin main as the default upstream, so future pushes only need git push.

Git asks for a username and password

When you run git push for the first time, Git will prompt you for credentials. GitHub no longer accepts account passwords for Git operations.

Enter your GitHub username when prompted for a username. For the password, you need a Personal Access Token (PAT). Create one in your GitHub account under Settings > Developer settings > Personal access tokens > Tokens (classic). Generate a token with the repo scope and paste it as your password.

Alternatively, you can install Git Credential Manager to handle authentication automatically via your browser.

After a successful push, you should see output showing your commits being uploaded, ending with a line that confirms the branch was set up to track the remote.

Seeing a permission error?

Make sure you copied the correct HTTPS URL from your own GitHub repository. The URL must point to a repository you own.

If you see a message about authentication failing, double-check that you entered your Personal Access Token (not your GitHub password) when prompted.

help me fix a GitHub push authentication error

Verify your repository on GitHub

The push is done. Now confirm that everything arrived safely on GitHub.

  • Switch back to your web browser.
  • Navigate to your repository at https://github.com/your-username/recipe-book (replace your-username with your GitHub username).
  • Confirm you can see all four files: README.md, .gitignore, guacamole.md, and chocolate-cake.md.
  • Click the Commits link (near the top of the file list) to view your full commit history.
  • Verify that all your commits are listed in chronological order, including the merge commit from your add-dessert branch.

What should I see?

Your repository's main page displays the contents of README.md rendered as formatted text below the file list. The commit history shows each commit message alongside the author name and email you configured in Step 1.

Files missing or commit history incomplete?

If you see fewer files than expected, make sure you committed all files before pushing. Run git status in your terminal to check for uncommitted changes, then push again with git push.

my GitHub repository is missing files or commits after pushing

Your recipe book is now live on GitHub for the world to see. You've mastered the full local-to-remote Git workflow. Up next, the Secret Mission challenges you to handle the trickiest part of team collaboration: merge conflicts.

Secret mission

Resolve a Merge Conflict

Merge conflicts happen when two branches change the same line in a file. They're the scenario that intimidates beginners most. In this mission, you'll intentionally create one, then resolve it by hand to prove you can handle real-world collaboration.

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely on your local machine and uses a free GitHub account, so there are no ongoing costs. Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

Resources you used:

  • Local recipe-book project folder on your Desktop.
  • GitHub recipe-book repository.
  • Git installed via your package manager.
  • Git global configuration stored in ~/.gitconfig.

Keep everything running

No action needed. Choose this if you're still actively building or want to keep practising Git commands in your recipe-book project.

  • Your local recipe-book folder stays on your Desktop.
  • Your GitHub repository remains publicly visible.
  • Git and your global configuration remain available for future projects.

Pause - I'll come back to this later

Free up visibility without deleting anything. Your files stay on disk and your GitHub repo stays intact, but you can hide it from the public.

  • On GitHub, navigate to your recipe-book repository.
  • Click Settings.
  • Scroll down to the Danger Zone section and click Change visibility.
  • Select Private to hide the repository from the public while keeping all your commits.
  • Your local files require no changes.

Delete - I don't want to use this again

Remove all project resources and start fresh. This is permanent.

Delete the local project folder:

  • Navigate out of the project folder and remove it by running:
cd ~/Desktop
rm -rf recipe-book

Delete the GitHub repository:

  • On GitHub, navigate to the main page of your recipe-book repository.
  • Click Settings.
  • Scroll down to the Danger Zone section and click Delete this repository.
  • Click I want to delete this repository.
  • Click I have read and understand these effects.
  • Type recipe-book to confirm, then click Delete this repository.

Remove Git global configuration:

  • Remove the global config file by running:
rm ~/.gitconfig

Uninstall Git:

  • Remove Git from your system by running:
sudo apt-get remove git

Keep Git installed?

Git is a fundamental developer tool you'll use in almost every future project. If you plan to continue learning, skip the uninstall step and keep Git on your machine.

Nice Work!

Nice Work!

You did it. You've gone from zero to a published GitHub repository with real version control skills.

Here's what you accomplished:

  • Created a Git repository from scratch, built a meaningful commit history, and used git diff and git log to inspect changes over time.
  • Created a feature branch, worked on it independently, and merged it back into main.
  • Connected your local repository to a remote on GitHub and pushed your full commit history for the world to see.
  • Resolved a merge conflict by hand, proving you can handle real-world collaboration scenarios.

Ready to quiz yourself?