What Is a Terminal?
What you'll learn
~12 min- Understand what a terminal is and why developers use it
- Distinguish between a terminal, a shell, and a command
- Recognize the parts of a terminal prompt
- Run your first commands and see how the terminal responds
By the end of this lesson, you will understand what a terminal is, why it matters for working with AI tools, and you will have typed your very first commands into one. No prior experience needed — we start from zero.
🔍New to computers? What files and folders actually are
A file is a single piece of information stored on your computer — a document, a photo, a song, or a piece of code. Many files have extensions (like .txt for text, .html for a web page, .py for Python code), which often help software identify the file type — but not all files use extensions, especially on Linux and macOS.
A folder (also called a directory) is a container that holds files and other folders. Think of your computer like a filing cabinet: folders are the drawers and dividers, files are the individual papers inside.
When you use the terminal, you navigate this same filing cabinet — but by typing names instead of clicking icons. It’s the same files and folders you see in your regular file explorer, but a different interaction style — more precise, scriptable, and powerful once you learn the commands.
The two ways to talk to your computer
Right now, you’re using your computer through a graphical user interface (GUI). You click on icons, drag windows around, and use menus. It’s visual, intuitive, and how most people have always used computers.
But there’s a second way — one that’s been around even longer:
The terminal.
A terminal is a text-based interface where you type commands and your computer responds with text. No icons. No menus. Just you and your computer, having a conversation through typed messages.
The mental model: texting your computer
Here’s the simplest way to understand it:
Using a GUI is like talking to someone face-to-face — lots of gestures, pointing, visual cues.
Using a terminal is like texting them — you type exactly what you want, and they text back.
When you text a friend “send me that photo from last night,” they know exactly what to do. When you type ls in a terminal, your computer knows exactly what to do — it lists all the files in your current folder.
That’s it. That’s the whole concept. The terminal is a text conversation with your computer, and once you learn a handful of “phrases” (commands), you can ask it to do almost anything.
Why do you need this?
Every LLM CLI tool — Claude Code, Gemini CLI, Codex CLI, Copilot CLI — runs inside a terminal. That is not the only way to use AI building tools anymore — Claude Code now has a web version, and GitHub Codespaces gives you a terminal in your browser — but the terminal is still where these tools are most powerful and flexible. We cover those cloud sandbox options in Module 5, Lessons 4-5.
For now, learning the terminal gives you the most flexibility. To become an orchestrator, you need to be comfortable with two things:
- Opening a terminal
- Typing commands in it
You don’t need to become a command line wizard. You need maybe 10-15 commands, and we’ll teach you every single one.
The terminal feels intimidating because of how it looks in movies — green text on black screens, hackers typing furiously. In reality, it’s just a text box where you type simple English-ish commands. If you can text, you can use a terminal.
🧬In Your Field: Biotechclick to expand
If you’ve ever used R in the console, you’ve already used something very close to a terminal. The R console is a text interface where you type commands and get results back. The terminal has a similar interaction model (type a command, get output), but the shell controls your operating system and files, while the R console executes R code. AI CLI tools like Claude Code can help you write R scripts, manage data pipelines, and automate repetitive analysis tasks — all from the terminal.
📊In Your Field: MIS / Businessclick to expand
In the business world, you’ll often hear about “automation” and “scripting.” Those workflows live in the terminal. When an analyst says they automated a reporting pipeline, they likely wrote a series of terminal commands. AI CLI tools bring that same power to anyone willing to type a few commands — no programming degree needed.
🏛️In Your Field: Government / State Devclick to expand
Government IT environments often restrict what software you can install, but in many setups terminal access is available through approved tools (for example SSH gateways, bastion hosts, or managed cloud shells). SSH, remote servers, and secure cloud environments all use the terminal as their primary interface. Learning these basics will help you work within those constraints rather than around them.
What does it look like?
When you open a terminal, you’ll see something like this:
user@computer:~$That’s called the prompt. It’s your computer saying “I’m ready — what do you want me to do?”
Your prompt may look different depending on your OS — for example, PS C:\Users\Name> in PowerShell on Windows, or name@MacBook ~ % on macOS. That’s normal. The core concept is the same: the prompt is waiting for your command.
Let’s break down each piece:
user— your usernamecomputer— your computer’s name~— where you currently are (your home folder)$— the “I’m ready” symbol
You type a command after the $, press Enter, and the computer responds:
user@computer:~$ pwd/home/userpwd means “print working directory” — it tells you where you are in the filesystem. We’ll cover this in detail in Lesson 3.
Try it yourself
Here’s a practice terminal right in your browser. Type pwd and press Enter to see where you are, then try ls to see what files exist.
Don’t worry about breaking anything — this simulator is a safe sandbox. Type help to see all available commands.
Key vocabulary
Before we go further, here are five terms you’ll hear constantly:
| Term | What it means | Analogy |
|---|---|---|
| Terminal | The application/window you type commands in | Your texting app |
| Shell | The program that interprets your commands | The “brain” that reads your texts |
| Command | An instruction you type | A text message |
| Directory | A folder | Same as a folder on your desktop |
| Path | The “address” of a file or folder | Like a street address |
The terminal is the window. The Shell Shell The program inside a terminal that interprets your commands. Learn more → is the program running inside it. It’s like how Chrome (the window) runs a web engine (the program inside). Most of the time, you don’t need to think about this distinction — but if you see people mention " Bash Bash The most common shell on Linux and WSL systems. Learn more → " or “zsh,” those are shell names. For this course, we use bash, which is the most common shell on Linux and WSL (Windows Subsystem for Linux). If you’re on Windows without WSL, you may be in PowerShell, where command behavior can differ slightly. We’ll note alternatives when needed.
A worked example: your first “conversation”
Let’s walk through what an actual terminal session looks like, step by step. Think of it as reading a text conversation:
user@computer:~$ echo "Hello, terminal!"Hello, terminal!
user@computer:~$ pwd/home/user
user@computer:~$ lsdocuments projects hello.txtHere’s what happened:
- You said:
echo "Hello, terminal!"— Theechocommand repeats text back to you. It’s like asking the computer to say something out loud. - You asked:
pwd— “Where am I right now?” The computer answered:/home/user(your home folder). - You asked:
ls— “What’s in this folder?” The computer listed three items: two folders and a file.
That’s it — three commands, three answers. Every terminal session follows this same pattern: you ask, the computer answers.
What you’ll be able to do
By the end of this module (5 short lessons), you’ll be able to:
- Open a terminal on any operating system
- Navigate around your files and folders
- Create, move, copy, and delete files
- Connect to remote environments like servers and Codespaces
- Feel confident when an AI tool says “run this command”
That’s the foundation. Once you have this, everything else — installing tools, running projects, deploying websites — becomes a matter of typing one or two commands.
What is a terminal?
In the prompt `user@laptop:~/projects$`, what does the `~` represent?
When Things Go Wrong
Use the Symptom → Evidence → Request pattern: describe what you see, paste the error, then ask for a fix.
Key takeaways
- A terminal is a text-based interface for talking to your computer — think of it as texting your machine.
- The prompt (like
user@computer:~$) tells you who you are, what machine you’re on, and where you are in the filesystem. - You only need about 10-15 commands to be effective — and we’ll teach every one.
- All AI CLI tools (Claude Code, Gemini CLI, etc.) run inside a terminal, which is why this skill matters.
- The terminal won’t bite — nothing happens until you press Enter, and
Ctrl+Cusually interrupts the current foreground command.
🔍Why text interfaces still exist in 2026
You might wonder: if GUIs are so intuitive, why does the terminal still exist? Three reasons:
- Speed. Once you know the commands, typing is faster than clicking through menus. Renaming 500 files takes one command vs. 500 clicks.
- Automation. You can save a sequence of commands as a script and run it again anytime. Try that with clicking.
- Remote access. When you connect to a server across the internet, you can’t see its screen — but you can type commands. The terminal works everywhere, on any connection speed.
This is why every developer, data scientist, and systems administrator still uses a terminal daily — and why AI CLI tools chose the terminal as their home.