Series: Overview | Process & Methodology | Engineering Thinking | Meta-Skills | Glossary (you are here)

This glossary is part of SWE for AI Orchestrators — a guide to the software engineering concepts that transfer to AI orchestration. These are the terms you’ll encounter during AI coding sessions, defined in plain English.

Contents

Computing fundamentals (the stuff nobody explains)

SWE (Software Engineer / Software Engineering) — a person who builds and maintains software professionally, or the discipline itself. Used throughout this guide as shorthand. When we say “SWEs do X,” we mean “professional software engineers, as a group, tend to do X.”

Terminal / terminal emulator — a text-based interface for controlling your computer. Instead of clicking buttons, you type commands. “Terminal” is technically the window; “shell” is the program inside it that interprets your commands. It looks intimidating but most AI orchestration only uses a handful of commands.

Command — a single instruction you give the computer by typing it into a terminal. ls, cd, git status, python script.py are all commands. Some commands are built into the shell; others are separate programs installed on your system; others are scripts you’ve written yourself. When a tool says “install the claude command,” they mean “install a program that you invoke by typing claude in your terminal.” When the AI tells you to “run this command,” it means “copy this exact line and paste it into your terminal.”

CLI (Command Line Interface) — any tool you interact with by typing commands in a terminal, as opposed to a GUI (Graphical User Interface) with buttons and menus. Most AI coding tools (Claude Code, Cursor’s terminal mode) are CLIs. Photoshop is a GUI.

IDE (Integrated Development Environment) — an application that bundles everything you need to write code into one window: a text editor, a way to run the code, debugging tools, and git integration. VS Code, Cursor, JetBrains, and Xcode are IDEs. You can write code in a plain text editor, but an IDE adds features (syntax highlighting, autocomplete, inline error detection, jump-to-definition) that make the work substantially faster. Pure CLI tools like Claude Code live entirely in the terminal; AI-augmented IDEs like Cursor embed the AI directly inside the editor. Most SWEs use both — an IDE for sustained coding, a terminal alongside it for running commands.

Shell — the program that reads your typed commands and executes them. Bash is the most common shell on Linux/Mac. Zsh is the Mac default (almost identical to Bash). PowerShell is the Windows equivalent. When someone says “run this in your shell,” they mean “type this in your terminal.”

Linux / Unix / macOS — Linux and macOS are both based on Unix, which is why they share commands (ls, cd, grep). Windows is a different lineage, which is why commands are different there. Most servers run Linux. Most AI developer tooling assumes a Unix-like environment.

sudo — “superuser do.” Run a command with administrator privileges. Like right-clicking “Run as Administrator” on Windows, but as a text command. You’ll see it in installation instructions.

PATH — a list of directories your shell searches when you type a command. If you type python and it says “command not found,” it means Python isn’t installed, or its location isn’t in your PATH. Most “command not found” errors are PATH issues.

Git — the version control system that tracks changes to files. See Checkpoint Discipline for how this applies to AI orchestration. Almost all code on Earth is tracked with git. Not to be confused with GitHub (a website that hosts git repositories) or GitLab (a competitor).

Repo (repository) — a project folder tracked by git. “Clone the repo” means “download a copy of the project.”

Tarball — a compressed archive file (.tar.gz or .tgz). Like a .zip file but using Unix compression. Named because it uses the tar (tape archive) program. You’ll encounter tarballs when downloading software or datasets.

SSH (Secure Shell) — a way to securely connect to and control a remote computer via the terminal. “SSH into the server” means “connect to the server’s terminal remotely.”

Permissions — who can read, write, or execute a file. When something fails with “permission denied,” it means your user account doesn’t have the right access level. Related to sudo and chmod (change mode — the command that modifies permissions).

Script — a file containing a sequence of commands that run automatically. A Python script, a Bash script, etc. Like a macro, but for the terminal.

Pipe (|) — sends the output of one command as input to another. cat file.txt | grep "error" means “read the file, then filter for lines containing ’error’.” Piping is how Unix commands compose — small tools chained together.

Flag / argument — options you pass to a command to change its behaviour. In python script.py --dry-run -v --output results.csv, --dry-run, -v, and --output results.csv are flags/arguments. Single-dash flags (-v) are usually one letter; double-dash flags (--verbose) are full words. When the AI gives you a command to run and it has mysterious dashes in it, those are flags.

Path (file path) — the address of a file on your computer. An absolute path starts from the root (/home/harrison/Documents/file.txt on Linux, C:\Users\Harrison\Documents\file.txt on Windows) and works from anywhere. A relative path starts from your current location — ./src/utils.py means “from where I am now, go into src/, find utils.py.” The ./ means “current directory.” The ../ means “one directory up.” When the AI says “save this to ./src/utils/helpers.py,” it means relative to wherever you’re currently working.

Working directory — the folder your terminal is “in” right now. When you type a command, it runs from this location. Relative paths are relative to it. If things aren’t found where you expect, you’re probably in the wrong directory. pwd (print working directory) shows where you are.

How software is built

Boilerplate — repetitive, standard code that’s basically the same every time. Setting up a new web project involves a lot of boilerplate. AI is excellent at generating boilerplate.

Scaffolding — generating the initial structure of a project (folders, config files, a basic app that runs). Like the framing of a house before the walls go up.

Refactoring — restructuring existing code without changing what it does. Like rewriting a paragraph to be clearer without changing its meaning.

Shipping — releasing software to users. “Did it ship?” means “is it live?” Deploying is the act of putting code on a server where users can access it.

Stack / tech stack — the combination of technologies used to build something. “What’s your stack?” means “what languages, frameworks, and tools are you using?” Full-stack means working on both the user interface (front-end) and the server/database (back-end).

Dependency — a library or package your code relies on. Like an ingredient in a recipe — if it’s unavailable or changes, your recipe breaks. Dependency hell is when dependencies conflict with each other or require incompatible versions.

Package — a bundle of pre-written code distributed as a single installable unit. numpy, requests, lodash are packages. A package manager (pip for Python, npm for JavaScript, Homebrew for macOS system tools) installs, updates, and tracks these.

Library — a collection of pre-written code you can call from your own code, instead of writing it from scratch. Importing numpy and calling numpy.mean([1, 2, 3]) is using a library. “Package” and “library” are often used interchangeably in casual conversation, but strictly: a package is how code is distributed (what you install), a library is how code is used (what you import and call). numpy is both — a package when you install it, a library when you use it.

Virtual environment / dependency file — a way to isolate a project’s dependencies so they don’t conflict with other projects. A virtual environment (Python’s venv, Node’s node_modules/) is a sandboxed space where packages are installed just for that project. A dependency file (requirements.txt in Python, package.json in JavaScript) lists exactly which packages a project needs. When the AI’s code won’t run on your machine, it’s often because you’re missing a dependency — the fix is usually pip install -r requirements.txt or npm install.

How code runs

Runtime — when the code is actually executing (as opposed to when it’s being written or compiled). “A runtime error” means it crashed while running, not while being built.

Compile-time — when source code is translated into executable code. Some errors are caught at compile-time (before running), others only at runtime (while running). Languages like Python handle compilation invisibly in the background (they’re often called “interpreted”).

Binary / source code — two forms the same program can take. Source code is the human-readable text a programmer wrote — a .py file, a .c file, a .rs file. A binary (sometimes called an “executable”) is what you get after a compiler has translated source code into the low-level instructions the CPU can actually run — unreadable to humans, but directly runnable by the machine. Languages split into two camps: compiled languages (C, Rust, Go) turn source into a binary ahead of time, and you ship the binary. Interpreted languages (Python, JavaScript, Ruby) ship the source code itself, and another program (the interpreter) reads and executes it line by line at runtime. “Did you build it from source?” means “did you compile it yourself, or did you download a pre-built binary?” Pre-built binaries are faster to install and don’t require a build toolchain; building from source lets you customise the build, target your exact system, and verify what’s actually in it. When you install git, python, or node, you’re installing binaries. When you install a Python package, you’re usually installing source code that Python will interpret.

Environment (dev, staging, prod) — different contexts where code runs. Dev is your local machine. Staging is a test server that mimics production. Prod (production) is the live system real users touch. Most bugs happen because something works in dev but not in prod.

Config / .env / environment variables — settings that change between environments (API keys, database URLs, feature flags). Stored outside the code so you can change behaviour without changing code.

stdout / stderr / exit code — how programs communicate results. stdout (standard output) is the normal output. stderr (standard error) is where error messages go. Exit code is a number the program returns when it finishes — 0 means success, anything else means failure.

Process — a running instance of a program. Your web browser is a process. A Python script is a process while it’s running. The operating system manages processes.

How teams work on code

PR (pull request) — a request that the maintainer of a branch “pull” your changes into it. You make your changes on a separate branch, then open a PR asking to merge them into the main branch. In teams, PRs are reviewed before merging — the maintainer checks your work before pulling it in.

Code review — having someone else read your changes before they go live. Catches bugs, shares knowledge. When orchestrating AI, the “writer/reviewer” pattern is code review applied to AI agents — one agent writes, a separate agent reviews with fresh context.

CI/CD (Continuous Integration / Continuous Deployment) — automated systems that test code when it’s pushed and deploy it when tests pass. You won’t set this up for personal projects, but you’ll hear the terms.

Linting / linter — automated style checking. A linter flags inconsistencies (unused variables, formatting issues) without running the code. Like a spell-checker for code.

Describing problems

Bug — a defect. Code that doesn’t do what it should.

Edge case / corner case — unusual inputs or conditions that the main logic doesn’t handle. “What if the file is empty? What if the name contains emoji? What if the date is February 29th?” Most bugs live in edge cases.

Happy path — the scenario where everything works as expected. The “happy path” through a login form is: user enters valid email, valid password, clicks submit, gets logged in. Testing only the happy path is how bugs ship.

Regression — a bug introduced by a change that breaks something that used to work. “We added the new feature, but it regressed the search functionality.” Regression testing checks that old features still work after new changes.

Stack trace — the error output that shows which functions were called, in what order, leading to the crash. Reading a stack trace is how you find where things went wrong. The most useful line is usually the last one that references your code (not library code).

Technical debt — shortcuts that save time now but cost time later. Like financial debt: sometimes worth taking on, always has interest payments. See Engineering Thinking for the full treatment.

Quiet failure vs loud failure — a loud failure crashes immediately with an error message — annoying, but you know something’s wrong and where to look. A quiet failure produces no error but does the wrong thing: silently deleting the wrong files, returning incorrect calculations, or saving corrupted data that you won’t discover for weeks. Quiet failures are far more dangerous because damage accumulates before you notice. Design principle: make failures loud. It’s better for a script to crash with “file not found” than to silently skip the file and produce incomplete results. When asking the AI to build something, say: “If anything unexpected happens, raise an error — don’t silently continue.”

Blast radius — how much damage a mistake can do. A typo in a config file that only affects one user has a small blast radius. A bad database migration that corrupts every user’s data has a large one. Before making a change, ask: “If this goes wrong, how bad is it?” The bigger the blast radius, the more carefully you should verify before proceeding.

Decision-making and culture

Scope creep — gradual, unplanned expansion of what a project includes. “While we’re at it, let’s also add…” is the sound of scope creeping.

Yak-shaving — a chain of prerequisites that takes you far from the original task. “I wanted to deploy my app, but first I needed to update my server, but first I needed to fix my SSH keys, but first I needed to upgrade my OS…” Each step is necessary, but you’ve lost sight of the original goal.

Bikeshedding — spending disproportionate time on trivial decisions (the colour of the bikeshed) while glossing over important ones (the design of the nuclear reactor). Named after Parkinson’s Law of Triviality.

Cargo culting — copying practices without understanding why they work. Named after Pacific Island cargo cults that built mock airstrips hoping planes would land. In software: copying code patterns or practices because “that’s how Company X does it” without understanding the context that makes them work.

DRY / SSOT (Don’t Repeat Yourself / Single Source of Truth) — two names for closely related ideas, often used interchangeably. The original formulation in The Pragmatic Programmer was: “Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.” That’s both — DRY is SSOT in the strict sense. In casual usage the two have drifted apart: DRY tends to get used narrowly about code (don’t copy-paste the same logic in two places — extract a shared function), while SSOT tends to get used about information more broadly (a user’s email address should live in one database column not three; the app’s version number should be defined in one config file not five; the list of supported regions should live in one place every part of the system reads from). Whichever name you use, the failure mode is the same: when the same fact exists in two places, they drift apart and you no longer know which is correct. When orchestrating AI, this matters because the AI will cheerfully create parallel documentation, duplicated config blocks, or redundant helper functions unless you tell it to read and update the existing one. “Is there already a source of truth for this?” is worth asking before every new file. WET (Write Everything Twice) is the humorous counterweight — sometimes a little duplication is clearer than a premature abstraction, especially when the two uses are likely to diverge over time. Knowing when to DRY and when to WET is a judgement call.

Footgun — a tool or feature that makes it easy to accidentally hurt yourself. “That API is a footgun — it silently deletes data if you pass the wrong parameter.”

Noop (no-op / no operation) — intentionally doing nothing, on purpose. Used in two ways: (1) “That code change was a noop” means someone made a change that looked like it would do something but actually didn’t — it’s a way of saying “this was pointless.” (2) A deliberate noop is a placeholder that keeps the structure intact without triggering real work — like a fire drill that tests the evacuation route without an actual fire. Useful for testing pipelines, verifying deployment processes, or confirming that a system runs end-to-end before you let it do anything real.

Backlog — a running list of all the things you might want to build. Some methodologies, like Basecamp’s Shape Up, argue against maintaining one — backlogs become a graveyard of stale ideas that create guilt and waste time grooming. Their alternative: if an idea is truly important, it will come back on its own. Let ideas go; shape them fresh when the time is right.

Spike — a time-boxed investigation to answer a specific question before committing to an approach. From Extreme Programming (XP). The output is a decision (proceed, pivot, or abandon), not shippable code. “I’ll spend 30 minutes figuring out if this API can do what I need.” See concept #7.

Vertical slice — a thin implementation that touches every layer of a system (UI, logic, data) to deliver one complete feature end-to-end. The opposite of building one layer at a time (horizontal slicing). Forces integration early when mismatches are cheap to fix. A walking skeleton is the thinnest possible vertical slice — barely functional but proving the pieces connect. See concept #8.

WIP limit (Work In Progress limit) — an explicit cap on how many tasks can be in progress at once. From Kanban. The counterintuitive insight: limiting WIP increases throughput because context switching has a real cost. For AI sessions, a WIP limit of one prevents scope creep and context pollution. See concept #9.

Architecture and structure

Close to the metal — working at a low level of abstraction, near the hardware. The opposite of working with a high-level tool that hides complexity. Assembly language is close to the metal; Python is far from it. Trade-offs: closer to the metal gives you more control, better performance, smaller memory footprint, and a more precise mental model of what the machine is actually doing — useful when performance matters (games, operating systems, embedded systems, high-frequency trading) or when you’re debugging something the high-level tools can’t explain. The cost is more code, more time, more expertise required, and more categories of bugs to worry about (memory management, buffer overflows, race conditions). Further from the metal gets you the opposite trade: you build faster, you lean on libraries that solve hard problems for you, and entire classes of bug become impossible — but you pay in performance overhead and in opacity when something breaks at a lower layer you can’t see into. Most modern software is built far from the metal because developer time is more expensive than CPU cycles, and the performance tax is usually invisible. You go closer when it isn’t.

Abstraction / abstraction layer — hiding complexity behind a simpler interface. A car’s steering wheel is an abstraction over the steering mechanism — you don’t need to understand rack-and-pinion to drive. Software is built in layers of abstraction.

API (Application Programming Interface) — the defined, stable, documented way one piece of software talks to another. Like a menu at a restaurant: you don’t need to know how the kitchen works, you just need to know what you can order and what you’ll get back. Why this matters to you: when a service offers an API, you can get structured, reliable data in a single call — the exact same response every time, in a format designed for machines to parse. The alternative is “scraping” their website, which is brittle (the layout changes and your code breaks), inconsistent (different pages show different views of the same underlying data), slower, and often against the service’s terms. Check for an API first. Many of the services you already use offer one: GitHub, Vultr, 1Password, Linear, Notion, Google Calendar, Obsidian, Stripe, Cloudflare. The AI often won’t volunteer this — it’ll happily start writing a web scraper when a two-line API call would be cleaner, more reliable, and permitted. Develop the reflex: before letting the AI build a workaround, ask “Does this service have an API we can use?” (Note: not every API is a public REST endpoint over HTTPS. Proton Mail, for example, doesn’t offer a general third-party API, but the Proton Mail Bridge desktop app runs locally and exposes your Proton account via standard IMAP/SMTP to any email client on your machine — that’s still an API in the broader sense of a defined, stable interface, just an older protocol rather than a REST one. IMAP, SMTP, LDAP, and SSH predate the web-API era but are no less “APIs.”)

Endpoint — a specific URL that an API responds to. Like a specific dish on the menu. /api/users might return a list of users; /api/users/123 might return one specific user.

REST — a style of API design where URLs represent resources and HTTP methods (GET, POST, PUT, DELETE) represent actions. Most web APIs are RESTful. You’ll encounter this when the AI sets up server-side code.

JSON (JavaScript Object Notation) — a standard text format for structured data, used everywhere in web programming. Looks like {"name": "Alice", "age": 30}. When the AI builds anything that talks to a server, JSON is almost certainly involved. Human-readable, which makes it a good format for data exchange — though punctuation-heavy, which makes it tedious to write and edit by hand. Compare to YAML below.

YAML (YAML Ain’t Markup Language) — another text format for structured data, optimised for humans rather than machines. The same data as the JSON example looks like:

name: Alice
age: 30

No braces, no quotes around keys, no trailing commas — indentation carries the structure. Rule of thumb: JSON is better when programs are exchanging data with each other (APIs, network requests, saved application state); YAML is better for config files that humans have to read and edit (Claude Code’s settings.json is an exception that proves the rule — GitHub Actions workflows, Kubernetes manifests, docker-compose files, and Hugo front matter are all YAML). Warning: YAML is whitespace-sensitive. A single misaligned space or a tab where there should be spaces can break the whole file, and the error messages are often cryptic. When the AI writes YAML, double-check the indentation.

MCP (Model Context Protocol) — a standard way to connect AI tools to external data sources and services. Instead of copy-pasting information into a chat, MCP lets the AI directly access things like your calendar, email, databases, or web scraping tools. Think of it as plugins for AI — you install an MCP server (e.g., for Google Calendar), and the AI can read and create events without you acting as the middleman. MCP is new (2024-2025) and the ecosystem is evolving rapidly.

Serialisation / deserialisation — converting data between formats. Turning a Python dictionary into JSON text is serialisation. Parsing that JSON back into a dictionary is deserialisation. Things break when the two sides disagree on the format.

Idempotent — an operation that produces the same result no matter how many times you run it. Setting a value is idempotent (setting x=5 twice still gives you x=5). Incrementing is not (incrementing twice gives you x+2, not x+1). Matters when operations might run more than once (network retries, script re-runs).

Clobbering / overwriting — when one operation destroys another’s output. “The deploy clobbered the config file” means a deployment process overwrote a configuration file that had been manually edited.

Upstream / downstream — relative position in a data or dependency flow. If service A sends data to service B, A is upstream and B is downstream. Changes upstream affect everything downstream.

Blocking / non-blocking — whether an operation makes you wait. A blocking call pauses everything until it finishes (like a phone call). A non-blocking call lets you continue and notifies you when it’s done (like a text message).

Back to: SWE for AI Orchestrators — 17 concepts across 3 tiers for non-engineers using AI coding tools.