---
title: "Meet the Terminal"
description: "Set up macOS Terminal or Ubuntu through Windows Subsystem for Linux. Practice checking your location, creating folders, and moving between them before downloading the website code."
canonical_url: "https://vercel.com/academy/build-and-launch-with-ai/meet-the-terminal"
md_url: "https://vercel.com/academy/build-and-launch-with-ai/meet-the-terminal.md"
docset_id: "vercel-academy"
doc_version: "1.0"
last_updated: "2026-09-25T16:42:53.658Z"
content_type: "lesson"
course: "build-and-launch-with-ai"
course_title: "Build and Launch with AI"
prerequisites:  []
---

<agent-instructions>
Vercel Academy — structured learning, not reference docs.
Lessons are sequenced.
Adapt commands to the human's actual environment (OS, package manager, shell, editor) — detect from project context or ask, don't assume.
The lesson shows one path; if the human's project diverges, adapt concepts to their setup.
Preserve the learning goal over literal steps.
Quizzes are pedagogical — engage, don't spoil.
Quiz answers are included for your reference.
</agent-instructions>

# Meet the Terminal

# Meet the terminal

Our website is live on Vercel. Next, we'll bring its code onto our computer so we can keep building it locally. We'll start by opening a terminal and creating a folder for the project.

A *terminal* is an application where we enter text commands. The *shell* reads those commands and carries them out. We'll use it to work with the website's files and, later, run the site on our computer.

## Outcome

Create a `projects` folder in your home directory and navigate into and out of it using the terminal.

## Hands-on exercise 2.1

### Open your terminal

Follow the setup for your computer, then continue to “Find your current folder.” Windows setup may require a restart.

When a shell is ready, it displays a *prompt* beside the cursor. It may include your username and end with `%`, `$`, or `>`. The code blocks show only the commands we'll type; the prompt stays in the terminal.

**On macOS:** Open Spotlight, search for Terminal, and open Apple's Terminal app. It's included with macOS. Apple's [Terminal guide](https://support.apple.com/guide/terminal/apd5265185d-f365-44cb-8b09-71a064a42125/mac) also describes how to open it from the Applications folder.

**On Windows:** We'll use Ubuntu through Windows Subsystem for Linux, or WSL. It provides a Linux environment for the command-line tools we'll use later. If Ubuntu is already installed through WSL, open it from Start and continue below.

For a new installation on Windows 11 or a supported Windows 10 version, open **PowerShell as administrator**. Enter this command and press Enter:

```powershell
wsl --install
```

This installs WSL and its default Ubuntu distribution. Restart when prompted, then open **Ubuntu** from Start. Follow its prompts to create a Linux username and password. Password characters won't appear while typing; that's expected. See Microsoft's [installation guide](https://learn.microsoft.com/en-us/windows/wsl/install) if setup reports an error or only displays help.

Use the Ubuntu window for the remaining commands. Microsoft recommends [keeping projects in the Linux filesystem](https://learn.microsoft.com/en-us/windows/wsl/setup/environment#file-storage) when using Linux tools, which we'll do by starting in Ubuntu's home directory.

### Find your current folder

Enter this command:

```sh
pwd
```

`pwd` means “print working directory.” A *directory* is a folder, and the working directory is the folder the shell is currently using. The printed *path* tells us where that folder is on the computer.

Before creating anything, let's move to our home directory, where our user files belong:

```sh
cd ~
pwd
```

Run each line separately, pressing Enter after it. `cd` means “change directory,” and `~` refers to your home directory. On macOS, its path normally starts with `/Users/`; in Ubuntu, it normally starts with `/home/`. Your username determines the rest.

### Create a place for projects

We need to create our folder before we can move into it. From the home directory, run:

```sh
mkdir -p projects
cd projects
pwd
```

`mkdir` creates a directory. The `-p` option lets us reuse an existing directory with that name without changing its contents. `cd projects` moves into the folder; the path from `pwd` should now end in `/projects`.

Successful `mkdir` and `cd` commands usually return to the prompt without printing a message. Use `pwd` to check where we landed.

Let's create one practice folder inside it:

```sh
mkdir -p "practice notes"
ls
```

`ls` lists the current folder's visible contents. With only this exercise folder present, it prints:

```text
practice notes
```

An existing projects folder may also list your other work. The quotes tell the shell that `practice notes` is one name, including its space.

### Move between folders

Keep those quotes when entering the practice folder:

```sh
cd "practice notes"
pwd
```

The path should end in `/projects/practice notes`. Without quotes, the shell would read `practice` and `notes` as separate arguments, which changes the command's meaning.

Move back to the containing folder, also called the *parent directory*:

```sh
cd ..
pwd
```

The two dots mean “one directory up.” We're back in `projects`. Changing folders doesn't move or change the files inside them.

**Requirements:**

1. Create or reuse `~/projects` and confirm its location with `pwd`.
2. Create the `practice notes` folder and find it with `ls`.
3. Enter that folder, then return to `projects` with `cd ..`.
4. Practice completing a folder name and recalling a command below.

## Try It

From `projects`, type `cd prac` without pressing Enter. Press Tab to let the shell complete the folder name. If several names match, type more of the name and press Tab again.

Inspect the completed command before running it. The shell may insert a backslash before the space, as in `practice\ notes`. That backslash keeps the space inside the folder name, serving the same purpose as our quotes.

Press Enter, then run `pwd`. Press the Up Arrow once to recall `pwd`, and Enter to run it again. Command history saves us from retyping; check what it recalled before running it.

Return to the projects folder from wherever you are:

```sh
cd ~/projects
pwd
```

The final path should match the projects location we recorded earlier. Leave this terminal open for the next lesson.

### `cd` reports that the directory doesn't exist

Run `pwd`, then `ls`. Check the folder's spelling and capitalization against the listing. A command such as `cd projects` looks inside the current folder; if we're already in `projects`, it would look for another `projects` folder inside it. Use `cd ~/projects` to return to the one in our home directory.

### The terminal waits instead of running the command

A missing closing quote can make the shell wait for more input. Its prompt may change to `>` or mention a quote. Press Ctrl+C to cancel the unfinished command, then retype `cd "practice notes"` with both straight double quotes from the `projects` folder.

## Commit

Save the full path printed by `pwd` for your projects folder in your course notes. This is our setup checkpoint. Git commits come after we download the website's code.

## Done-When

- [ ] macOS Terminal or Ubuntu through WSL is open and accepts commands.
- [ ] `pwd` shows the projects folder in your home directory.
- [ ] `ls` shows `practice notes`, and you can enter it and return.
- [ ] Tab completion and Up Arrow history work, and the projects path is saved.

## Solution

After completing your operating system's setup, these commands create the folders and practice moving between them. Run one line at a time:

```sh
cd ~
mkdir -p projects
cd projects
mkdir -p "practice notes"
ls
cd "practice notes"
pwd
cd ..
pwd
```

The first `pwd` shows the practice folder. The second shows its parent, `projects`, where we'll download Small Hours Studio in “Keep Your Code.”


---

[Full course index](/academy/llms.txt) · [Sitemap](/academy/sitemap.md)