Day 8: Intro to Git and CI/CD fundamentals

Lesson #8

👋 Welcome to Week 2 of the 14-Day Course. In the first week, we covered everything about AI agents; this week, we will cover software engineering fundamentals.

Agenda for today:

• Stop watching tutorials

• What is Git?

• Common myths about Git

• Setting up your terminal

• What is CI/CD?

• Main commands you need to know

🛑 STOP watching endless AI tutorials!

If you’ve made it this far in the 14-Day Free Course, you’re clearly hungry to learn - but let me tell you something most people won’t:

There is a reason why you might feel stuck and overwhelmed.

It’s not because you’re not smart enough.
It’s because you’re stuck in a loop of consuming instead of building.

The truth is: You don’t need more theory.
You need to take more action.

How?
With real guidance from real experts and a system that keeps you accountable.

This is a golden time to be a builder.

Stop underestimating yourself and wasting your potential.

If you feel ready to become an AI Engineer in 2025, this 6-week program is for you.

In 6 weeks, you will go from confused and overwhelmed to a confident and fearless AI engineer, who ships daily.

🔥You’ll learn how to:

• Think like a full-stack AI engineer. (With both Python and TypeScript tracks)

• Overcome self-doubt with guidance from seniors

• Design, build, and deploy real-world AI agents

• Build apps you’re proud to show off in interviews and on LinkedIn

This isn’t for passive learners. It’s for builders.

This is the bootcamp we wish had existed when we were just starting out!

📌 Join today. Spots are limited.

Reserve yours now → [Follow this link]

What is Git? (not Github)

Please don’t confuse Git with GitHub. They are two different things.

What is Git?

What is Github?

🤔 Common myths about Git

Myth: “Git is only for big teams.”
Fact: It is not only for teams. Even solo developers benefit from Git’s safety net and history tracking.

Myth: “Git is too complex for beginners.”
Fact: With the right guidance and practice, anyone can master the basics and build confidence fairly quickly.

Keep in mind that. Git is the industry-standard version control system, used by over 70% of developers worldwide to track code changes, collaborate seamlessly, and safeguard project history.

So if you are serious about your AI engineering journey, you need to master it!

Good news. It is not that hard!

Follow the steps below and save the links.

Setting Up Your Development Environment

1. Create a GitHub Account

• Register at github.com

• 🔗 Learn the basics of Github

• 🔗 GitHub Docs: Hello World

2. Configure SSH/HTTPs for GitHub

This way you can work with your local machine and push your code straight to your repo on Github.

• 📹 Connecting GitHub to your local environment (via HTTPS/SSH)

• Test your connection to GitHub

  • SSH

ssh -T [email protected]

• HTTPS

curl -I https://github.com

If the connection is successful, you'll see either a greeting (SSH) or a response like HTTP/2 200 (HTTPS).

💻 Terminal Setup

The terminal is your command center. It lets you interact directly with your computer’s operating system, manage files, run programs, and most importantly, work with Git.

Here are the main commands you need to know.

1. But first, choose & configure your terminal

• Windows: Install Windows Terminal or Git Bash

• macOS: Use Terminal or install iTerm2

• Linux: Use your distribution's terminal

2. Essential Terminal Commands

These help you move around your file system quickly and see what’s inside each folder.

• File and Folder Management:

When coding, you’ll constantly be adding, renaming, and organizing files. Mastering these saves time and keeps your project neat.

Version Control with Git

Git Fundamentals

1. What is Version Control?

The Problem Version Control Solves

• Code History & Tracking: Ever saved multiple versions of a file like "final.doc", "final_v2.doc", "really_final.doc"? Version control eliminates this by tracking all changes in a structured way.

• Collaboration Challenges: Without version control, team members might overwrite each other's work or struggle to merge changes from multiple contributors.

• Backup & Recovery: Provides a complete history that serves as both documentation and backup, allowing you to recover previous states if something goes wrong.

• Experimentation Safety: Enables developers to try new ideas without fear, as they can always revert to previous working versions.

2. How Git Tracks Changes Over Time

• Snapshots, Not Differences: Unlike other systems that store differences between files, Git takes a "snapshot" of all files at each commit

• The Three States of Git:

  • Working Directory: Where you modify files

  • Staging Area (Index): Where you prepare changes for a commit

  • Repository: The .git directory storing all versions

• Commit Hash: Every commit gets a unique identifier (hash) based on its contents

• Branching Model: Git uses lightweight branches that make parallel development easy

Main and Development Branches

Installing Git

1. Installation Instructions by Operating System

For Windows:

1. Download the installer from git-scm.com

2. Run the installer with default options (customize if needed)

3. Important options to consider:

   • Default editor (recommend VS Code or Notepad++ for beginners)

   • PATH environment (recommend "Git from the command line and also from 3rd-party software")

For macOS:

1. Option 1 - Homebrew (recommended):

brew install git

1. Option 2 - Standalone Installer:

   • Download from git-scm.com

   • Run the .dmg installer and follow prompts

2. Option 3 - Command Line Tools:

xcode-select --install

2. Initial Git Configuration

After installing Git, set up your identity with the following commands:

# Set your name (appears in commit history)
git config --global user.name "Your Name"

# Set your email (links commits to your GitHub account)
git config --global user.email "[email protected]"

3. Verifying Your Installation

Check that Git is properly installed by running:

git --version

You should see something like:

git version 2.41.0

View your configuration settings:

git config --list

Basic test to ensure Git is working:

# Create a test repository
mkdir git-test
cd git-test
git init

# You should see a message about initializing a repository# and a .git directory will be created

Common Installation Troubleshooting:

• "Command not found": Git isn't in your PATH. Try restarting your terminal or adding Git to your PATH manually.

• Permission issues: Try running the commands with administrator privileges (sudo on Mac/Linux).

• SSL certificate problems: May need to disable SSL verification temporarily or update certificates.

Resources for Further Help:

• Official Git documentation: git-scm.com/doc

• GitHub's Git guides: docs.github.com/en/get-started

With Git properly installed and configured, you're ready to start tracking changes and collaborating on projects!

📝 Core Git Commands

git clone <repo_url>
git status
git add .
git commit -m "Your message"
git push origin main
git pull origin main

Essential Git Commands

1. Repository Management

• git init: Creates a new Git repository in the current directory, adding a hidden .git folder to track changes.

• git clone [url]: Downloads a complete copy of an existing repository, including all files and history.

• git remote: Lists, adds, or removes connections to other repositories (like GitHub) for sharing code.

2. Tracking Changes

• git status: Shows which files are modified, staged, or untracked in your working directory.

• git add [file]: Adds changes from your working directory to the staging area, preparing them for commit.

• git commit -m "message": Records staged changes to the repository with a descriptive message.

• git diff: Displays line-by-line changes between your working directory and the last commit.

3. Branching & Merging

• git branch [name]: Creates a new branch to develop features or fix bugs independently from the main codebase.

• git checkout [branch]/git switch [branch]: Switches your working directory to a different branch.

• git merge [branch]: Integrates changes from one branch into your current branch.

• Resolving merge conflicts: Manually editing files where Git can't automatically combine different changes.

4. Remote Operations

• git fetch: Downloads objects and refs from a remote repository without merging changes into your branches.

• git pull: Fetches changes from a remote repository and automatically merges them into your current branch.

• git push: Uploads your local commits to a remote repository, sharing your changes with others.

• git pull origin main fetches the latest changes from the main branch on GitHub and merges them into your local code.

Congratulations on completing Day 8!

👏 You’ve just started your journey as a real engineer. In the next lesson, you will start working with AI coding assistants like Cursor!

If you’re still scared of touching more fun AI projects, like multi-agents, complex backend, or deploying anything real. That ends here.

In 6 weeks, you’ll:

• Build AI-powered apps from scratch

• Design and deploy real-world agents using Python or TypeScript

• Master the stack used by top startups (Next.js, MCP, Mastra, OpenAI Agent SDK,etc)

• Join a squad of builders who don’t wait for permission

We give you:

✅ The roadmap
✅ The daily guidance and resources
✅ The weekly challenges
✅ The momentum

You just need to show up.

⏳ Seats are filling fast.

Use an Early Access Coupon Code “EARLY” for $210 OFF before it expires on May 30