Set Up Terminal and Git

Why work locally

So far, you've been working with code through web interfaces — creating a GitHub account, deploying a template on Vercel. That's a great start, but it's not how professional development actually works day to day. To really work with code, you need to bring things to your own computer and work locally.

Why? Because web-based tools have real limitations. GitHub has a built-in editor, but it's basic — you can't run your project, see changes in real time, or use the powerful tools that make development efficient. Cloud-based AI tools like Lovable, Bolt, or v0 are great for quick experiments, but they come with their own constraints — you can't always import existing projects, and you have less control over the details.

Working locally gives you speed (instant feedback when you test changes), power (access to professional development tools), and flexibility (work offline, run multiple projects, full control over your environment). It's also the workflow that most companies use: you write and test code on your computer, push it to GitHub when it's ready, and the hosting service deploys it automatically. That's the cycle we'll use throughout this course.

To work locally, you need two things: a terminal and Git installed on your machine.

The terminal

Also called the command line, console, or shell, it is a text-based interface to your computer. Instead of clicking buttons and navigating menus, you type commands. If you've never used one, it can feel a little scary — a blank window with a blinking cursor, no icons, no buttons. When I was learning this stuff as a kid, the terminal was the scariest part — but also the most exciting. Something about typing commands and watching things happen feels like you've unlocked a superpower. That feeling doesn't go away, by the way. It's genuinely one of the most powerful tools you'll learn. Many tasks that would take multiple clicks and menu navigations happen in a single typed command.

The terminal follows a consistent syntax: every command has a structure, usually a program name followed by options and arguments. Once you understand the pattern, new commands start to feel intuitive. And here's the thing — you only need a handful of commands to be effective. Seriously, about five or six will carry you through this entire course.

The terminal is also critical for working with AI. AI coding agents — the ones built into tools like Cursor — use the terminal constantly. They run commands, install packages, start servers, and manage Git. If you understand what the terminal does, even at a basic level, you'll understand what your AI tools are doing behind the scenes. That makes you a much more effective director.

Git and cloning

Now, Git. You already learned what Git is in the first exercise — a version control system that tracks changes to your files. You also learned about GitHub, the cloud platform built on top of Git. The important distinction is that Git is a tool that runs on your computer, while GitHub is a service in the cloud. You need Git installed locally to interact with your GitHub repositories from your machine.

Once Git is installed, you can clone a repository — which means downloading a complete copy of it to your computer. You get all the files, all the folders, and the entire version history. The clone maintains a connection to the original GitHub repository, so you can push changes back later.

Cloning uses a simple command: git clone followed by the repository URL. The files download to whatever directory (folder) you're currently in. You navigate between directories using the cd command — short for "change directory." To see what's in a directory, you use ls. And cd ~ takes you to your home directory — your personal folder on the computer.

Essential commands

These commands — cd, ls, git clone, git status — are the building blocks of working in the terminal. They're simple individually, but together they unlock a completely different way of working with code. And they're universal: the same commands work no matter what project you're working on, what framework you're using, or what AI tool you're directing.

A note on safety

One safety note: be thoughtful with terminal commands, especially ones you don't fully understand. Unlike deleting a file through Finder (which moves it to the trash), deleting something through the terminal is permanent. Be especially careful with commands that start with sudo — that's a prefix that grants admin-level access and can make destructive changes. If you see a sudo command in documentation or AI output, make sure you understand what it does before running it. Always work within a Git repository so you can revert changes, and don't hesitate to use AI assistants to explain commands you're unsure about. The source code you're working with is always recoverable as long as it's tracked by Git.