# From Zero to Builder
## A Plain-English Guide to Getting Started with Claude Code

*For people who want to build things but have never written code before.*

---

## Before You Start: What Is This?

Claude Code is a version of Claude that lives inside your computer — not in a browser tab.
You talk to it in a "terminal" (the text window that looks like a hacker movie), and it can
actually build things: websites, tools, apps, automations.

The browser version of Claude talks. Claude Code **does**.

You give it an idea. It writes the code, creates the files, fixes the errors, and explains
what it's doing at every step. Your job is to guide it, review its work, and tell it when
something's wrong.

This guide gets you from zero to your first working project.

---

## What You'll Need

Before installing anything, make sure you have:

- ✅ A computer (Mac, Windows, or Linux)
- ✅ A Claude **Pro, Max, Team, or Enterprise** account
  → The free plan does NOT include Claude Code. Upgrade at claude.ai/settings/billing.
- ✅ About 45 minutes for the initial setup
- ✅ A project idea (or see "Picking Your First Project" at the end of this guide)

---

## Part 1: Install Claude Code

### On Mac (Recommended for beginners)

**Step 1 — Open Terminal**

Press `Cmd + Space`, type **Terminal**, press Enter.
A window with a blinking cursor appears. This is the terminal. Don't be scared of it —
it's just a way to give your computer instructions by typing.

**Step 2 — Install Node.js**

Node.js is a tool that Claude Code's add-ons (MCPs) need to run.

1. Go to **https://nodejs.org**
2. Click the big "LTS" download button
3. Open the downloaded file and click through the installer (all defaults are fine)
4. When done, type this in your terminal and press Enter:

```
node --version
```

You should see something like `v22.x.x`. That means it worked.

**Step 3 — Install Claude Code**

Type this in your terminal and press Enter:

```
npm install -g @anthropic-ai/claude-code
```

Wait for it to finish. It'll print a lot of text — that's normal.

**Step 4 — Log in**

Type this and press Enter:

```
claude
```

Your browser will open. Log in with your Claude account and click Authorize.
Then go back to the terminal.

**Step 5 — Check it works**

```
claude --version
```

If you see a version number: **Claude Code is installed. You did it.**

---

### On Windows

Windows needs one extra step first: WSL (Windows Subsystem for Linux).
This gives you a proper environment for Claude Code to run in.

**Step 1 — Open PowerShell as Administrator**

Click the Start menu, search for "PowerShell", right-click it, and choose
"Run as administrator."

**Step 2 — Install WSL**

```
wsl --install
```

Press Enter and let it run. Restart your computer when it asks you to.

**Step 3 — Set up Ubuntu**

After restart, Ubuntu will open automatically and ask you to create a username
and password. Write these down.

**Step 4 — Install Node.js inside Ubuntu**

In your Ubuntu terminal:

```
curl -fsSL https://fnm.vercel.app/install | bash
source ~/.bashrc
fnm install 22
```

**Step 5 — Install Claude Code**

```
npm install -g @anthropic-ai/claude-code
```

**Step 6 — Log in**

```
claude
```

A browser window opens. Log in and authorize.

> **Prefer not to use a terminal?**
> Claude Code also has a Desktop App for Mac and Windows.
> Download it from https://claude.ai/download — no terminal needed.

---

## Part 2: Create Your First Project Folder

Every project lives in its own folder. Claude Code works with the files in whichever
folder you're in when you start it.

**Create a folder:**

```
mkdir my-first-project
cd my-first-project
```

`mkdir` creates the folder. `cd` moves you into it.

**Start Claude Code:**

```
claude
```

You're now in a session. You can talk to Claude, ask it to build things, and watch it work.

**Try this right now:**

```
Build me a simple webpage that says "Hello World" with a blue background.
```

Claude will create a file called `index.html`. Open it in your browser to see your
first web page. That file? You built it. Kind of.

---

## Part 3: Write Your CLAUDE.md (Do This Every Project)

CLAUDE.md is a file that tells Claude everything it needs to know about your project
at the start of every session. Without it, Claude has to guess. With it, Claude knows
exactly how to help you.

Create a file called `CLAUDE.md` in your project folder. Here's a starter template:

```markdown
# Project: [Your Project Name]

## What this project is
[One paragraph. What does it do? Who is it for?]

## My level
I am learning to code with Claude's help. Please explain what you're doing as you go.
Use plain language. Don't use technical terms without explaining them.

## Rules you must follow
- Tell me what you're about to do before you do it
- Don't delete any files without asking me first
- Don't deploy or publish anything without my explicit approval
- When you're unsure about what I want, ask me rather than guessing
- Keep code simple — I prefer readable over clever

## What "done" looks like for version 1
[Describe the minimum working version of your idea]
```

Fill in the brackets. This takes 10 minutes and saves hours of confusion.

---

## Part 4: Install MCP Servers (Superpowers for Claude Code)

MCPs are plugins. They give Claude Code extra abilities beyond just working with files.
Here are the four most useful ones for beginners.

Open a terminal (not inside a Claude session — exit first by typing `/exit`) and run
each command:

### 1. Context7 — Fresh Documentation

Claude's knowledge has a cutoff date. Context7 gives it up-to-date documentation
for any library or framework, so it doesn't write outdated code.

```
claude mcp add context7 -- npx -y @upstash/context7-mcp@latest
```

### 2. Sequential Thinking — Smarter Problem Solving

This makes Claude plan before it acts. It breaks big tasks into steps before writing
a line of code. Dramatically reduces mistakes on anything complex.

```
claude mcp add sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking
```

### 3. Filesystem — Full File Access

Lets Claude read and write files anywhere on your computer, not just the current folder.

```
claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem ~
```

### Verify they're installed

```
claude mcp list
```

You should see all three in the list.

Then start a session and test:

```
List all the tools and MCP servers you have access to.
```

---

## Part 5: Your First Real Session

Here's exactly how to start a productive session:

**1. Navigate to your project folder**

```
cd path/to/your-project
```

(On Mac: if your project is in Documents, type `cd ~/Documents/my-first-project`)

**2. Start Claude Code**

```
claude
```

**3. Give Claude your context**

```
Read CLAUDE.md and tell me what you know about this project.
```

Claude will read the file and summarize what it knows. Correct anything wrong.

**4. Start building**

Use this template for your first real request:

```
I want to build [describe your project]. Version 1 should [what v1 does].
Before writing any code, please:
1. Tell me what approach you'd recommend
2. List the files we'll create and what each one does
3. Ask me if I have any questions before starting
```

Getting the plan first — before Claude writes anything — is the most important habit
for beginners.

---

## Part 6: Habits That Keep You Out of Trouble

### Always use Git (even if you don't understand it)

Git is a save system for code. Run these three commands after anything important works:

```
git init        (only the first time, sets up Git in your folder)
git add .
git commit -m "describe what works"
```

If something breaks after this, you can always go back.

### Read before you approve

When Claude says "I'm going to do X," read it before saying yes.
Ask: "What could go wrong?" or "Can you explain why?"

### The reset move

If a session goes sideways, type this:

```
Stop. Let's start this task over from scratch. Here's what I actually want: [describe it]
```

Claude doesn't hold grudges. Starting fresh is always an option.

### Check your progress

Every few sessions, ask Claude:

```
Summarize what we've built so far, what's working, and what's next.
```

This keeps you oriented and gives Claude a chance to surface things you may have missed.

---

## Part 7: Useful Commands to Know

| Command | What it does |
|---------|-------------|
| `claude` | Start a new session in the current folder |
| `claude mcp list` | See all installed MCP plugins |
| `claude --version` | Check your Claude Code version |
| `claude doctor` | Run a health check if something seems broken |
| `/help` | Inside a session: show available commands |
| `/mcp` | Inside a session: check MCP connection status |
| `/exit` | Leave a session and return to the terminal |

---

## Picking Your First Project

Not sure what to build? Here are ideas by level:

### Total beginner (never coded at all)
- A personal webpage about yourself
- A landing page for a business idea
- A simple tip calculator or quiz

### Comfortable with computers, new to code
- A tool that reads a spreadsheet and formats a report
- A simple contact form that saves responses to a file
- A personal dashboard with links, notes, and a to-do list

### Ready to stretch
- A web app where you can add and check off tasks (saved between sessions)
- A tool that pulls data from a public API and displays it nicely
- A bot that reads a folder of files and answers questions about them

**When you pick your project, tell Claude:**

```
My project idea is: [description]
I'm a complete beginner. Before we write any code, help me understand:
1. Is this realistic for a first project?
2. What's the simplest version we could build first?
3. What should I put in my CLAUDE.md?
```

---

## Troubleshooting Quick Reference

| Problem | What to try |
|---------|-------------|
| `command not found: claude` | Close and reopen terminal; run `claude doctor` |
| Authentication error | Make sure you have Pro/Max/Team plan |
| MCP not showing up | Run `/mcp` inside a session to reconnect |
| `npx: command not found` | Re-install Node.js from nodejs.org |
| Something random broke | Run `claude doctor` — it diagnoses most issues |
| Claude keeps forgetting context | Check CLAUDE.md exists; say "Read CLAUDE.md" at session start |

---

## You're Ready

Here's your launch checklist:

- [ ] Claude Code installed (`claude --version` works)
- [ ] Node.js installed (`node --version` works)
- [ ] context7 MCP installed
- [ ] sequential-thinking MCP installed
- [ ] Project folder created
- [ ] CLAUDE.md written
- [ ] Git initialized in your project folder
- [ ] First session started, first file built

Welcome to being a builder.

---

*For deeper guidance, the `non-builder-to-builder` skill includes full tutorials,
project prompt templates, and Windows-specific setup instructions.*