Why this lesson comes before the AI lessons CORE
Lesson 2.1 was conceptual. Every lesson after this one is hands-on — you'll install a local LLM, set up a cloud account, write your first directed edit, and (in Module 3) clone a real codebase and direct an agent through it. All of those steps assume you can do four things: open files in an editor, type commands in a terminal, run a Python script, and use git to manage code.
If you've never opened Terminal on a Mac, or you're unsure what the difference is between Notepad and Visual Studio Code, this lesson is for you. If you already use a terminal daily and have Python and git installed, the recipes below will take twenty minutes total — skim, verify, and skip ahead.
The point of the lesson is not that you become a developer overnight. The point is that you have these four tools open and working before Lesson 2.3 asks you to type ollama pull llama3.1:8b-instruct-q4_K_M, and before Module 3 asks you to type git clone <starter-repo>. Those commands make sense once the tools are in place. Cold, they look like a foreign language.
What is an editor? CORE
An editor is a program that shows you the contents of files and lets you change them. You've probably used Microsoft Word or Google Docs — those are editors too, but they're designed for prose (paragraphs, fonts, page breaks). For directing AI to do real work, you want an editor designed for code and plain text — files where every space and line matters.
A modern code editor does three things Word does not:
- Shows you a folder of files in a sidebar, so you can switch between them with a click.
- Highlights syntax — colors keywords, strings, and structure so the shape of a file is visible at a glance, even if you're not the one writing the code.
- Opens a terminal inside itself so you can run commands without switching windows.
You will install VS Code (Visual Studio Code) below. It is free, runs on Mac, Windows, and Linux, and is the editor this course assumes. If you prefer Sublime Text, JetBrains, Cursor, or Zed, all are fine alternatives — VS Code is just the common baseline. (You don't need to know what those alternatives are; the point is that no single editor is required.)
What is a terminal? CORE
A terminal is a program that lets you type commands one at a time and see the response, instead of clicking buttons. You may have seen one before — a black or dark-blue window with text scrolling by. It looks intimidating; it is not. A terminal is just a typing-based way to ask your computer to do things.
On a Mac the app is called Terminal. On Windows the app is called Windows Terminal (or just “Terminal” in newer versions). Both come pre-installed. When this course says “open your terminal,” it means: open that app, or use the integrated terminal inside VS Code.
You may see the words “shell” or “command line” used to refer to the same thing. They're near-synonyms in casual use; you can ignore the distinction. The recipes call out when a Mac command and a Windows command differ.
What is Python? CORE
Python is a programming language. It is one of the most common languages for AI work and the one this course's example projects use. You will not be writing Python from scratch in this course — that is what the AI agent is for. You will, however, run Python scripts (the agent will write or modify them, and you'll execute the result), read short Python files (so you can review what the agent changed), and use Python tools that come with the language.
Why Python specifically? Two reasons. First, Python is what most beginner-friendly AI tooling assumes — the test script in Lesson 2.4 is Python; the starter codebase in Module 3 is Python; many course examples are Python. Second, Python is good at small, readable scripts: ten lines of Python often do what a hundred lines of another language would. That readability matters when you're reviewing an agent's diff — the highlighted view of what the agent changed, with added lines and removed lines side by side. You'll see your first one in Lesson 2.4.
If you've taken a computer science course or any “intro to coding” class, you've likely seen Python already. If you haven't, that's fine — this course does not require you to read or write code yourself. The agent reads and writes code on your behalf. What you do need is the ability to run a command in a terminal, recognize when something has gone wrong (an error message, an unexpected output), and ask the agent to explain or fix it. That's the bar.
What is git? CORE
Git is your safety net. When you direct AI to edit your files and an edit goes sideways — and a few will — git lets you back out cleanly. “Revert this commit” is the most reassuring sentence in this entire course, and you cannot say it without git. That is the load-bearing reason a non-coder still installs git.
Underneath the safety net, git is a tool that records snapshots (called commits) of your project so you can see what changed between two points, undo a bad change, or share a project with someone else. GitHub is a related but distinct thing: a website that hosts git projects in the cloud. Git runs on your computer; GitHub stores projects on the internet.
This course uses git for three concrete things: cloning starter projects (downloading them from GitHub), committing the changes an agent makes (saving snapshots so you can revert), and protecting secrets (keeping your .env file out of any project that might end up online).
Git itself can do far more — branching, merging, collaborating with a team — but you don't need any of that for this course. The handful of commands you'll actually use are introduced as you encounter them in Module 3. For now, just know what git is for and why you're installing it.
Why these four tools matter for directing AI CORE
Three things you cannot do well without them:
See exactly what changed. When you direct an AI to edit a file, you want to see the diff — the highlighted before-and-after of what the agent changed. The editor (or git) shows you that. Without it, you're guessing whether the agent did what you asked.
Run small commands the agent suggests. AI coding agents will routinely tell you “run this command to verify” — things like python script.py or git status. The terminal is where those commands run. Without one, you can read the agent's suggestion but not act on it.
Recover when something breaks. When an edit goes sideways — and a few will — git lets you back out cleanly. “Revert this commit” is the most reassuring sentence in this entire course, and you cannot say it without git.
Module 1 told you that an agent is model + loop + tools + state. The editor is your window into the state. The terminal is your window into the tools. Python is one of the things the agent will most often act on. Git is your safety net. Together they are how you direct.
Install VS Code and open your course working folder RECIPE
| Tool | Visual Studio Code (VS Code) |
| Version tested | 1.88 |
| Last verified | 2026-04-17 |
| Next review | 2026-07-17 |
| Supported OSes | macOS, Windows (Linux equivalents callout below) |
Steps
- Browse to https://code.visualstudio.com/download. Download the installer for your OS.
- macOS: open the .zip, drag Visual Studio Code.app into your Applications folder. Windows: run the installer, accept defaults, and on the advanced options screen, make sure “Add to PATH” is checked. (This is what lets you launch VS Code by typing code in a terminal later.)
- Launch VS Code. The first time it opens, accept the default theme; you can change it later.
- Confirm your course working folder exists. (You created one in Lesson 1.5.) On macOS it's typically ~/ai-architect-academy/. On Windows it's typically C:\Users\<your-name>\ai-architect-academy\. (The ~ at the start of the Mac path is shorthand for your home folder — it expands to /Users/your-name/. You will see this ~ shorthand throughout the course; it is just a way to write “starting from my home folder” without spelling out your full username every time.)
- In VS Code, go to File → Open Folder and select your course working folder. VS Code opens the folder. The left sidebar shows the files inside it.
- Open the integrated terminal: View → Terminal (or use the keyboard shortcut: Ctrl+` on Windows, Cmd+` on Mac — that's a backtick, the character above the Tab key). A terminal pane opens at the bottom of the VS Code window, already pointed at your project folder.
- Verify: in the integrated terminal, run ls (Mac) or dir (Windows). You should see your my-first-loop.md from Lesson 1.5.
- If your file from Lesson 1.5 is named my-first-loop.txt instead of my-first-loop.md, rename it now. In VS Code's sidebar (the file list on the left), right-click my-first-loop.txt → choose Rename → change the .txt at the end to .md and press Enter. The contents stay exactly the same; the new extension just tells VS Code to treat the file as markdown, which makes headers, bullet points, and bold text render nicely when you open it. From this lesson forward, every file the course asks you to create will end in .md — same plain-text file, just labeled so editors know what to do with it.
Safe default — Editor configuration
- Do not install random extensions from untrusted authors. Extensions run code on your machine.
- Do turn off “auto-upload-to-AI” settings in any extension that offers them, until you've read what they upload.
- If you only ever launch VS Code by clicking its dock/desktop icon, that's fine — but typing code . in a terminal opens the current folder in VS Code. Useful from Lesson 2.4 onward.
Linux equivalents. On Linux, install VS Code via your distro's package manager or from https://code.visualstudio.com/docs/setup/linux. Everything else in this recipe works the same.
Five terminal commands you actually need RECIPE
| Tool | macOS Terminal, Linux Terminal, or Windows Terminal (PowerShell) |
| Last verified | 2026-04-17 |
You don't need to become a shell expert. You need five commands. Spend ten minutes here and you'll be fine for the rest of the course.
| What it does | Mac / Linux | Windows (PowerShell) |
|---|---|---|
| Show the folder I'm in | pwd | pwd (or Get-Location) |
| List files in this folder | ls | ls (or dir) |
| Go into a folder | cd <folder-name> | cd <folder-name> |
| Go up one folder | cd .. | cd .. |
| Print a file's contents | cat <filename> | Get-Content <filename> |
A few more useful things to know:
- Tab to autocomplete. Start typing a folder or filename, hit Tab — the shell finishes the name for you. This saves enormous amounts of typing and prevents typos.
- Up arrow for previous command. Hit Up to recall the command you just ran. Useful when you typed something wrong and want to fix it.
- clear clears the screen. When the terminal gets too cluttered.
- Copy and paste. On Mac: Cmd+C / Cmd+V. On Windows Terminal: Ctrl+C doesn't paste; use right-click or Ctrl+Shift+V to paste, and Ctrl+C to interrupt a running command.
Try this for ten minutes
- Open your terminal (the integrated VS Code one, or a standalone Terminal app).
- Run pwd (meaning: type pwd into the terminal and press Enter). Note the folder you're in.
- Run ls (or dir on Windows). You should see the files in your course working folder.
- Run cd ... You moved up one folder. Run pwd again — confirm.
- Run cd ai-architect-academy (or whatever you named your folder). You moved back in.
- Run cat my-first-loop.md (or Get-Content my-first-loop.md on Windows). The contents print to the screen.
If all six steps work, you have a working terminal. That is the entire bar for this lesson.
If something doesn't work — paste the error to an AI.
If any of those six commands gives you an error or behaves unexpectedly, copy the entire output (including any red text), paste it into Claude.ai (or whichever chat AI you're using), and ask "What does this error mean and how do I fix it?" Don't spend twenty minutes debugging by yourself before asking. Surfacing errors to an AI is the directing habit Lesson 1.5 introduced, and it scales to everything you'll do for the rest of the course.
Safe default — Terminal habits
- Read commands before you paste. A terminal will run anything you paste, including destructive things. When a course or AI agent gives you a command, read it once before pressing Enter.
- Never paste a command that starts with sudo or rm -rf from an untrusted source. Those have admin powers and can delete things permanently.
- If a command is taking too long or seems stuck, press Ctrl+C (Mac, Linux, and Windows alike). That interrupts the running command and gives you the prompt back.
Install Python and git RECIPE
| Tools | Python 3.10+ and git |
| Last verified | 2026-04-17 |
| Next review | 2026-07-17 |
| Supported OSes | macOS, Windows (Linux notes below) |
This recipe installs both at once. Each takes about five minutes.
Step 1 — Check what you already have
In your terminal, run these two commands:
python3 --version (Mac/Linux)
python --version (Windows)git --versionIf both print version numbers (Python 3.10 or higher; any git version is fine), skip to Step 4.
If either says “command not found” or shows an older version, continue with Step 2 (Python) or Step 3 (git) for whichever is missing.
Step 2 — Install Python (only if needed)
macOS. Python comes pre-installed but is often an older version. Install Python 3.12 from https://www.python.org/downloads/ — click the macOS download button, run the installer, accept defaults. After it finishes, close all terminal windows and open a fresh one, then run python3 --version again to confirm.
Windows. Browse to https://www.python.org/downloads/, click the big yellow “Download Python 3.12” button, run the installer. Important: on the first installer screen, check the box that says “Add python.exe to PATH” before clicking “Install Now.” This is the same kind of PATH check you did for VS Code. Without it, your terminal won't find python. Close all terminal windows after install and open a fresh one to verify with python --version.
Why versions matter. This course assumes Python 3.10 or newer. Some older Macs ship with Python 2.7 (very old) under the bare name python. That's why Mac/Linux users use python3 explicitly — it forces the modern version.
Step 3 — Install git (only if needed)
macOS. The easiest path: open your terminal and run git --version. If git isn't installed, macOS will pop up a dialog offering to install the “Command Line Developer Tools.” Click “Install” — that bundle includes git plus a few other useful tools. It takes 5–10 minutes. After it's done, run git --version to confirm.
Windows. Download from https://git-scm.com/download/win. Run the installer. Accept defaults except on the “Adjusting your PATH environment” screen, choose “Git from the command line and also from 3rd-party software” (the recommended middle option). Close terminal windows, open a fresh one, run git --version to verify.
Step 4 — Configure git with your name and email (one-time setup)
Git tags every commit with your name and email so you (and anyone who reads your project later) can see who made each change. Run these two commands once, substituting your own info:
git config --global user.name "Your Name"
git config --global user.email "you@example.com"The email doesn't have to be public — you can use a personal address. If you have a GitHub account and care about commits being attributed to it, use the email associated with that account.
Verify with git config --global --list. You should see your name and email printed back.
Python ships with a tool called pip for installing additional Python packages. Module 3 verifies pip works the first time it actually installs something, so there's no separate verification step here. If your Python install completed cleanly, pip is there.
Safe default — When tools say “permission denied”
- Don't run installers as sudo (Mac/Linux) or as Administrator (Windows) unless the official docs explicitly tell you to. Both Python and git installers handle their own permission prompts; you should not need to pre-elevate.
- Don't pip install random packages from the internet without reading what they do. A pip install runs code from someone else's project on your machine — same trust model as a terminal command.
- Never share the contents of ~/.gitconfig (the file git config --global writes to). It contains your name and email; other than that it's typically harmless, but treat it like any other personal config.
Linux equivalents. python3 is almost always pre-installed on Linux. Install pip with sudo apt install python3-pip (Debian/Ubuntu) or your distro's equivalent. Install git with sudo apt install git. Same git config --global setup applies.
Try it CORE
Foundation warmup
What you do.
- Open VS Code on your course working folder.
- Open the integrated terminal (View → Terminal).
- In the terminal, run pwd and confirm you're in the right folder.
- Run cat my-first-loop.md (or Get-Content my-first-loop.md). The file's contents should print.
- In the editor, click my-first-loop.md in the sidebar to open it. Add a single new line at the bottom: Tested editor + terminal on [today's date].
- Save the file (Cmd+S Mac, Ctrl+S Windows).
- Run cat my-first-loop.md again in the terminal. The new line should appear.
- Run python3 --version (Mac/Linux) or python --version (Windows). Note the version number — it should be 3.10 or higher.
- Run git --version. Note the version number.
- Run git config --global --list. Confirm you see user.name=... and user.email=...
What this proves. All four tools — editor, terminal, Python, git — are installed and pointed at the right folder. Module 3 picks up here and walks you through the first real git workflow against a starter project; you don't need to initialize git in your working folder yet.
Done with the hands-on?
When the recipe steps and the activity above are complete, mark this stage to unlock the assessment, reflection, and project checkpoint.
Quick check CORE
Five questions. Pick the best answer, then reveal the explanation.
Show explanation
Answer: B. Two different tools for two different jobs. The editor is your window onto files (the agent's state); the terminal is your window onto commands (the agent's tools). A confuses “terminal” with messaging. C is a common beginner conflation. D is wrong — both are local programs on your computer.
Show explanation
Answer: C. Either the standalone Terminal app or VS Code's integrated terminal works. The integrated one is convenient because it's already pointed at your project folder. A is a Windows app and isn't a terminal. B is the editor — but its integrated terminal (View → Terminal) is correct. D is unrelated.
Show explanation
Answer: B. Two dots after cd means “go up one folder.” A and D are not real commands. C goes to the root of the file system, which is much further up than usually intended.
Show explanation
Answer: B. Git tracks changes locally; GitHub stores those tracked projects on a website. You can use git without GitHub (and many people do); you cannot use GitHub without git. A is the most common beginner conflation. C and D are wrong.
Show explanation
Answer: A. Lesson 2.4 will run a Python script to test your API key. Module 3 will ask you to git clone a starter repo. Both require the tools to already be installed and verified — that's what this lesson sets up. B is true for traditional coding roles but isn't the point here. C and D are wrong.
Reflection prompt
Terminal first impressions.
In 4–6 sentences: Before this lesson, had you ever opened a terminal? If yes, on what kind of computer and for what purpose? If no, what was your reaction the first time the cursor blinked at you in this lesson? Most people find a terminal mildly intimidating the first time and routine within a week — what would help you cross from one to the other faster?
Project checkpoint
Record the four tools in your loop file.
Open my-first-loop.md. Add four lines:
Editor: [VS Code / other]
Terminal: [comfortable / mostly comfortable / still figuring out] — one note about what's still unclear, if anything.
Python: [version number from python3 --version or python --version]
Git: [version number from git --version; configured with name + email]
Save the file. The “still figuring out” answer is honest and useful — Lesson 2.3 onward will keep using the terminal, so any unclear thing is worth flagging now.
Next in Module 2
Lesson 2.3 — Running a local LLM on your own machine.
Now that the foundation tools are in place, you'll install a local LLM runner, pull an 8-billion-parameter model, hold your first local conversation, and measure latency and tokens-per-second on your own hardware.