Setup

Before you build anything, you need your tools set up. I know — setup is boring. You want to build stuff. But trust me, getting this right now saves you hours of pain later. I'm going to walk you through every single tool you need, why you need it (not just 'install this'), what you should see when it's working, and what to do when it inevitably goes wrong. This is a one-time thing. Once it's done, it's done.

The Terminal — your new best friend

The terminal (also called command line, console, or shell) is a text-based way to talk to your computer. Instead of clicking icons, you type commands. It sounds old-school, but it's how real software gets built. Every developer uses it, and you will too.

On macOS: Press Cmd + Space, type 'Terminal', hit Enter. That's it — you already have it.
On Windows: You need Windows Terminal (download from Microsoft Store) or, even better, WSL (Windows Subsystem for Linux) which gives you a real Linux environment inside Windows.

When you open Terminal, you'll see something like this:
`
yourname@your-mac ~ %
`

That blinking cursor is waiting for you to type something. Try this right now:
`
echo "Hello World"
`

You should see Hello World printed back at you. Congrats — you just ran your first command. The terminal isn't scary. It's just texting your computer.

A few terminal basics you'll use every day:

pwd — 'print working directory' — tells you where you are right now
ls — lists the files and folders in your current location
cd folder-name — changes directory (moves into a folder)
cd .. — goes back up one folder
mkdir my-project — creates a new folder called 'my-project'
clear — clears the screen when it gets cluttered

Try them now. Type pwd and hit Enter. Type ls and see what comes up. Type cd Desktop to go to your Desktop. Type ls again. You're navigating your computer with text. That's all the terminal is.

Common error: If you see zsh: command not found: something — it means that tool isn't installed yet. Don't panic, it's just telling you what's missing.

Code Editor — Cursor vs VS Code (and why I recommend Cursor)

A code editor is where you look at and edit code files. Think of it like Microsoft Word, but for code. You need one.

VS Code (Visual Studio Code) is free, made by Microsoft, and is the most popular editor in the world. Download it from code.visualstudio.com.

Cursor is basically VS Code with AI superpowers built in. It's built on the same foundation as VS Code, so it looks and feels identical, but it has built-in AI features like code completion and inline chat. Download it from cursor.com.

My recommendation: use Cursor. Since this entire course is about building with AI, having AI integrated directly into your editor makes sense. But honestly, either one works fine. They open the same files, they look the same, they have the same extensions. If you already have VS Code and don't want to switch, keep it.

After installing, open it and you should see a welcome screen. That's it for now. We'll come back to it.

Making your editor comfortable

This sounds minor but it matters. You're going to spend hours looking at code. Make it pleasant.

1. Pick a dark theme — most developers use dark themes because staring at a white screen for hours hurts your eyes. In Cursor/VS Code: Cmd + Shift + P (Mac) or Ctrl + Shift + P (Windows), type 'Color Theme', and browse options. I like 'One Dark Pro' or 'GitHub Dark'.
2. Increase font size if needed — Settings > search 'font size' > bump it up to 14 or 16.
3. Install the Prettier extension — this auto-formats your code so it always looks clean. Go to the Extensions panel (the square icon on the left sidebar), search 'Prettier', install it.
4. Install a file icon theme — search 'Material Icon Theme' in extensions. It gives different icons to different file types so you can tell them apart at a glance.

Don't spend more than 10 minutes on this. You can always tweak it later.

Node.js — the engine that runs your code

Here's what Node.js actually is: when you write JavaScript code, something needs to run it. Web browsers can run JavaScript (that's how websites work), but you're not building websites in a browser — you're building applications on your computer and servers. Node.js is the engine that runs JavaScript outside of a browser. Think of it as the engine in your car. You don't need to understand how the engine works internally. You just need it installed so things can run.

Don't install Node.js directly. Use nvm (Node Version Manager) instead. Why? Because different projects sometimes need different versions of Node.js. nvm lets you switch between versions with one command. Trust me, future you will thank present you.

Installing nvm and Node.js — step by step:

Step 1: Install nvm. Open your terminal and paste this:
`
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
`

You'll see a bunch of text scroll by. At the end, it'll say something about adding lines to your profile. Important: close your terminal completely and open a new one. The installation added some configuration that only loads when Terminal starts fresh.

Step 2: Verify nvm is installed. In your NEW terminal window, type:
`
nvm --version
`

You should see something like 0.39.0. If you see nvm: command not found instead — don't panic. This is the most common issue. It usually means your terminal didn't load the nvm configuration. Try this fix:
`
source ~/.zshrc
`
(or source ~/.bashrc if you're using bash). Then try nvm --version again.

Step 3: Install Node.js using nvm:
`
nvm install --lts
`

This installs the latest LTS (Long Term Support) version — the stable, reliable one. You'll see it download and install. Then:
`
nvm use --lts
`

Step 4: Verify Node.js works:
`
node --version
`

You should see something like v20.11.0 (the exact number might be different, that's fine).
`
npm --version
`

You should see something like 10.2.4. npm is Node's package manager — it installs libraries and tools. It comes free with Node.js.

If both commands show version numbers, you're golden. Node.js is ready.

Common Node.js / nvm issues and fixes:

Issue: nvm: command not found after installation
Fix: Close ALL terminal windows, open a fresh one, and try again. If that doesn't work, run source ~/.zshrc (macOS) or source ~/.bashrc (Linux/WSL).

Issue: node: command not found after installing via nvm
Fix: Run nvm use --lts again. Sometimes the version isn't set as default. To make it permanent: nvm alias default node

Issue: Permission errors when installing packages globally
Fix: This is exactly why we use nvm instead of installing Node directly. If you're seeing EACCES errors, you probably installed Node without nvm. Uninstall it and start over with nvm.

Issue: You're on Windows and none of this works
Fix: nvm has a Windows version called nvm-windows. Download it from github.com/coreybutler/nvm-windows. The commands are the same after installation.

Git — save points for your code

Let me explain Git like you're five: Git is a save-point system for your code, like in a video game. Every time you reach a good state — something works, a feature is done, you're about to try something risky — you create a save point (called a 'commit'). If you mess things up, you can go back to any previous save point. If you want to try something experimental, you can create a branch (a parallel timeline) and if it doesn't work out, you just go back to the main timeline.

Without Git, when you break your code at 2am and can't remember what you changed — you're screwed. With Git, you type one command and you're back to the last working version. It's also how you'll upload your code to GitHub and deploy to servers.

Installing Git:

On macOS: You might already have it. Type this in terminal:
`
git --version
`

If you see a version number like git version 2.39.0, you're done. If you see a popup asking to install Command Line Tools — say yes, wait for it to install, then try again.

If that doesn't work, install Homebrew first (it's a package manager for macOS — think of it as an app store for command-line tools):
`
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
`

Then:
`
brew install git
`

On Windows: Download from git-scm.com and run the installer. Use the default settings.

After installing, configure your identity (Git needs to know who's making the save points):
`
git config --global user.name "Your Name"
git config --global user.email "your@email.com"
`

Use your real name and the email you'll use for GitHub.

The Git commands you'll actually use (there are hundreds, but you need about 6):

`
git init # start tracking a project (do this once per project)
git status # see what's changed since the last save point
git add . # stage all changes (prepare them for saving)
git commit -m "what you did" # create a save point with a description
git push # upload your save points to GitHub
git pull # download the latest version from GitHub
`

That's it. Those 6 commands cover 90% of what you'll do with Git. Claude Code can also handle Git for you — it can commit, push, and manage branches. But understanding these basics means you'll know what's happening when it does.

Pro tip: git status is your friend. When in doubt, run git status. It tells you exactly what state your project is in — what's changed, what's staged, what's committed. I run it dozens of times a day.

Claude Code CLI — your AI coding partner

This is THE tool. This is the thing that makes everything possible. Claude Code is a command-line interface that lets you work with Claude directly in your terminal, inside your project. It can see your files, understand your entire codebase, write code, run commands, create files, fix bugs, and help you build things. It's not a chatbot in a browser — it's an AI that lives in your project and understands the context of what you're building.

Install it globally with npm (which you have because you installed Node.js):
`
npm install -g @anthropic-ai/claude-code
`

You'll see some installation output. When it's done, verify it works:
`
claude --version
`

You should see a version number. If you see claude: command not found, try closing and reopening your terminal.

How to use it: Navigate to any project folder in your terminal and just type:
`
claude
`

That's it. Claude Code starts up, reads your project files, and waits for your instructions. You type what you want in plain English. It writes code, creates files, runs commands — whatever's needed. This is the workflow you'll use for the entire course.

Getting your Anthropic API key — step by step

Claude Code needs an API key to talk to Claude's brain (the AI model). Here's exactly how to get one:

1. Go to console.anthropic.com in your browser
2. Click Sign Up and create an account (use Google, GitHub, or email — whatever's easiest)
3. Once you're in the dashboard, look for API Keys in the left sidebar
4. Click Create Key
5. Give it a name like 'claude-code' (the name doesn't matter, it's just for you to remember what it's for)
6. Copy the key immediately. It looks something like sk-ant-api03-xxxxxxxxxxxx. You will only see it once. If you lose it, you'll need to create a new one.
7. Add credits: Go to Billing in the sidebar. You need to add money to your account because Claude Code is pay-per-use. Start with $5-10 — that's plenty for learning. You'll see your usage in the dashboard.

The first time you run claude in your terminal, it will ask you for this API key. Paste it in, hit Enter, and you're connected.

IMPORTANT: Treat your API key like a password. Never share it publicly, never paste it in a public chat, never commit it to Git. If someone gets your key, they can use your credits. If you accidentally expose it, go back to the console and delete it immediately, then create a new one.

The .env file — keeping secrets safe

You're going to hear about .env files a lot in this course. Let me explain what they are and why they matter.

A .env file is a simple text file that stores sensitive information — API keys, database passwords, secret tokens — that your application needs but that you never want to share publicly. The name starts with a dot, which means it's a hidden file on macOS/Linux (you won't see it in Finder unless you enable hidden files).

It looks like this:
`
ANTHROPIC_API_KEY=sk-ant-api03-xxxxxxxxxxxx
DATABASE_URL=postgresql://user:password@localhost:5432/mydb
SECRET_TOKEN=some-random-string
`

Just key-value pairs, one per line. Your application reads these values at startup.

Critical rule: Your .env file should NEVER be committed to Git. That's what .gitignore is for — it's a file that tells Git which files to ignore. One of the first things you'll do in every project is make sure .env is listed in .gitignore. Claude Code knows this and will usually set it up for you, but always double-check. Accidentally pushing an API key to GitHub is one of the most common (and costly) mistakes beginners make.

Folder structure basics — where to put your projects

Before you start building, let's set up a clean workspace. You want all your projects in one place, not scattered across your Desktop and Downloads folder.

Open your terminal and run:
`
mkdir ~/projects
cd ~/projects
`

This creates a projects folder in your home directory. Every new project you build will live inside here. So your structure will look like:
`
~/projects/
my-first-app/
campaign-tool/
lead-manager/
...
`

When you start a new project, you'll do:
`
cd ~/projects
mkdir my-new-project
cd my-new-project
claude
`

And you're ready to build. Clean, organized, easy to find. Trust me, you do NOT want to be the person with 47 random project folders scattered everywhere. I learned that the hard way.

GitHub — your code's home on the internet

GitHub is where your code lives online. Think of it as Google Drive, but for code — with superpowers. You'll use it to:

- Back up your code (if your laptop dies, your code is safe)
- Deploy your applications (services like Vercel connect directly to GitHub)
- Collaborate (if you ever work with others)
- Show off your work (your GitHub profile is your portfolio)

Go to github.com and create a free account if you don't have one.

Then connect your local Git to GitHub. The easiest way is with the GitHub CLI:
`
brew install gh
gh auth login
`

Follow the prompts — it'll open a browser for you to authenticate. Once done, you can create repos and push code without dealing with SSH keys or tokens manually.

Alternatively, Claude Code can handle GitHub operations for you once you're authenticated.

First test — let's verify EVERYTHING works

Let's do a quick end-to-end test to make sure all your tools are installed correctly. Open your terminal and run each command one at a time:

`
node --version
`
Expected: something like v20.11.0

`
npm --version
`
Expected: something like 10.2.4

`
git --version
`
Expected: something like git version 2.39.0

`
claude --version
`
Expected: a version number

If ALL four commands show version numbers — you're set. Every tool is installed and working.

If any of them fail, go back to that tool's section above and follow the troubleshooting steps. Or — and this is the real workflow — describe the error to Claude in the web interface (claude.ai) and ask for help fixing it. You're already using AI to solve problems. That's the whole point.

Let's actually USE Claude Code for the first time

Let's do something real. Not just verify installations — let's actually build something tiny to prove the whole workflow works.

`
cd ~/projects
mkdir hello-test
cd hello-test
claude
`

Claude Code will start up. You might see it ask for your API key if this is the first time — paste it in. Then type this:

"Create a simple Node.js script that prints 'Hello, I'm building with AI!' and also shows the current date and time."

Claude will create a file, probably called something like index.js or hello.js. It'll write the code for you. Then you can run it:
`
node index.js
`

And you should see your message and the current date/time printed in the terminal. You just built something with AI. It's tiny, it's simple, and it proves that your entire toolchain works: terminal, Node.js, Claude Code, and your API key. Everything is connected.

Troubleshooting cheat sheet — if things go wrong:

- command not found for ANY tool — close all terminal windows, open a fresh one, try again. Most installation issues are fixed by restarting the terminal.
- Permission denied / EACCES errors — you're probably trying to install globally without the right permissions. This is why we use nvm for Node.
- npm ERR! during installation — try running npm cache clean --force then try the install again.
- Claude Code asks for API key every time — make sure you're entering it correctly. It stores it locally after the first time.
- Terminal looks completely different than expected — you might be using a different shell. Run echo $SHELL to check. /bin/zsh and /bin/bash are both fine.
- Git asks for username/password when pushing — you need to set up authentication. Use gh auth login (GitHub CLI) or set up an SSH key.
- Everything was working yesterday and now it's not — run nvm use --lts to make sure Node is active. Sometimes a new terminal session doesn't load the right Node version.

When in doubt: copy the entire error message and paste it into Claude (web or CLI). That's the skill. That's the workflow. You'll be doing this forever, and it works every time.

Sanity check — are you ready to build?

If you've followed everything above, here's what you should have:

- [ ] Terminal open and you can type commands
- [ ] Cursor or VS Code installed and you can open files
- [ ] node --version shows a version number
- [ ] npm --version shows a version number
- [ ] git --version shows a version number
- [ ] claude --version shows a version number
- [ ] You have an Anthropic API key stored (Claude Code doesn't ask for it anymore)
- [ ] You have a ~/projects folder for your work
- [ ] You have a GitHub account
- [ ] You successfully ran Claude Code and built the tiny hello-test script

If you can check all of those boxes — you are 100% ready to start building real projects. The setup is done. You won't need to do this again. From here on out, it's all about building things.

And if something on that list didn't work — that's totally fine. Describe the problem to Claude (on claude.ai for now), paste the error message, and ask for help. You're already practicing the core skill: describing problems clearly and letting AI help you solve them. That's literally the entire course in a nutshell. Let's go build something real.