Essential Commands

By the end of this lesson, you will be able to create, read, copy, move, rename, and delete files entirely from the terminal. These six commands, combined with the three navigation commands from the last lesson, give you everything you need for day-to-day file management.

The mental model: a desk with drawers

Think of the terminal as sitting at a desk:

• mkdir = adding a new drawer (creating a folder)
• touch = putting a blank sheet of paper in a drawer (creating a file)
• cat = picking up a sheet and reading it
• cp = photocopying a sheet (the original stays)
• mv = moving a sheet to a different drawer (or writing a new label on it)
• rm = permanently deleting a sheet (no recycling bin)

Your toolkit

In the last lesson you learned to navigate (pwd, ls, cd). Now you’ll learn to do things — create folders, create files, move them around, and read their contents.

Here are the six commands you need:

Practice terminal

Use this simulator to follow along with every exercise below. It has a pre-built filesystem so you can experiment freely.

Creating things

mkdir — Make a directory (folder)

mkdir my-project

This creates a new folder called my-project in your current directory. Think of it as clicking “New Folder” in your file explorer.

touch — Create an empty file

touch notes.txt

This creates an empty file called notes.txt. If the file already exists, it updates its “last modified” timestamp (hence the name “touch” — you’re just touching it).

Reading things

cat — Show file contents

cat notes.txt

This prints the contents of notes.txt to your screen. It’s how you quickly peek at what’s inside a file without opening an editor.

Try reading a file in the simulator above — run cat documents/notes.txt from your home directory to see what’s in it.

Moving and copying things

cp — Copy a file

cp original.txt backup.txt

This creates a copy of original.txt named backup.txt. The original stays untouched — just like photocopying a document.

cp notes.txt documents/notes.txt

This copies notes.txt into the documents folder.

mv — Move (or rename) a file

mv has two uses — it both moves and renames files. The syntax is the same either way:

Move a file to a different location:

mv notes.txt documents/notes.txt

Rename a file (move it to a new name in the same location):

mv old-name.txt new-name.txt

A helpful way to remember: mv is like cut-and-paste, while cp is like copy-and-paste.

Deleting things

rm — Remove a file

rm notes.txt

This permanently deletes notes.txt. There is no trash can. There is no undo.

To delete a folder and everything inside it:

rm -r my-folder

The -r flag means “recursive” — delete the folder and all its contents. Think of it as emptying a drawer and then removing the drawer itself.

Worked example: setting up a project from scratch

Here’s a realistic workflow — the kind of thing you’ll do regularly when starting a new project with an AI CLI tool:

# Step 1: Create the project folder and go inside
mkdir my-website
cd my-website

# Step 2: Create the main files
touch index.html
touch style.css
touch app.js

# Step 3: Create subdirectories for organization
mkdir images
mkdir data

# Step 4: Verify the structure
ls
# app.js  data  images  index.html  style.css

# Step 5: Check where we are
pwd
# /home/user/my-website

In just a few commands, you’ve created a basic project structure. When you use AI CLI tools later, they’ll do this for you automatically — but understanding what they’re doing gives you power and confidence.

Common patterns

Here are patterns you’ll use all the time:

Create a project and move into it (one line):

mkdir project-name && cd project-name

The && means “and then” — create the folder, then move into it. The second command only runs if the first succeeds.

Check before you delete:

ls my-folder          # See what's inside first
rm -r my-folder       # Then delete if you're sure

Copy a whole folder:

cp -r my-project my-project-backup

The -r (recursive) flag works with cp too — it copies the folder and everything inside.

Create multiple files at once:

touch file1.txt file2.txt file3.txt

You can pass multiple filenames to touch in a single command.

Practice challenge

Try this sequence in the simulator above, starting from /home/user:

1. Create a new folder called experiment
2. Navigate into it
3. Create three files: data.csv, analysis.py, README.md
4. Go back to your home directory (hint: cd .. to go up one level, or cd ~ to go home)
5. Copy the entire experiment folder to experiment-backup
6. Verify both folders exist with ls

Quick reference

Key takeaways

• Six commands handle all file operations: mkdir, touch, cat, cp, mv, rm.
• cp is copy-and-paste. mv is cut-and-paste. rm is the shredder (no undo).
• Always ls before rm to verify you’re deleting the right thing.
• Use -r (recursive) when working with folders: cp -r to copy folders, rm -r to delete folders.
• You now know 9 core terminal commands (pwd, ls, cd, mkdir, touch, cat, cp, mv, rm). That’s genuinely enough to use any CLI tool effectively.

What’s next

You now have the full set of essential terminal commands. In the next lesson, we’ll set up your working environment — VS Code, remote connections, and cloud alternatives — so you have the right cockpit for everything that follows.