Loading NormieClaw
97 tech and AI terms explained in plain English — no jargon, no judgment.
Showing 97 of 97 terms
An AI that doesn't just answer questions — it does things. You give it a goal, and it figures out the steps, uses tools, browses the web, writes code, sends messages, and handles it. More intern than chatbot.
Why you care: This is what separates "I asked ChatGPT a question" from "my AI actually handled the whole task while I was at lunch." Agents are why the hype is real this time.
Think of it as a waiter. Your app tells the waiter what it wants, the waiter goes to the kitchen (another app), and brings back your food (data). You never see the kitchen. You just eat.
Why you care: Every time you "Sign in with Google," check the weather in an app, or your Spotify playlist loads — that's an API doing the legwork. The whole internet is basically waiters talking to kitchens.
A password for machines, not humans. When your app needs to talk to another service (a weather API, an AI model, a payment processor), it identifies itself with an API key — a long string of random characters. It's basically the app saying "here's my badge, I'm allowed to be here."
Why you care: API keys are the most commonly leaked secret in tech. People accidentally push them to GitHub, paste them in public forums, or hardcode them in apps. If someone gets your API key, they can use the service as you — and you get the bill. Treat them like credit card numbers.
Your computer has a specific chip type — like how cars have different engines. The two that matter right now: ARM (newer Macs, phones) and x86 (most Windows PCs, older Macs). Software made for one doesn't work on the other.
Why you care: Sometimes when you download something, it asks you to pick. If you have a newer Mac, pick ARM. If you pick wrong, stuff breaks or runs super slow. When in doubt, just ask your OpenClaw — it already knows.
Making a computer do a repetitive task so a human doesn't have to. Set it up once, let it run forever. The whole point is that once you automate something, it costs you zero time going forward.
Why you care: This is the actual superpower of tech. Every hour spent building an automation is (theoretically) infinite hours saved. The people who get rich are usually the ones who found the thing worth automating.
An auth token with a specific format: Authorization: Bearer [your-token-here]. When your app sends a request to an API, it includes this header to prove it's authorized. "Bearer" literally means "the person carrying this token is allowed in." It's like a VIP wristband — whoever has it gets access.
Why you care: If you're tinkering with APIs or reading developer documentation, you'll see Bearer tokens everywhere. If you see Authorization: Bearer sk-abc123... in a tutorial, they're showing you where to put your auth token. Don't share the actual token value with anyone. It's a key.
A parallel version of your code. Like alternate timelines in a sci-fi movie. The "main" branch is the official version. You create a new branch to try something experimental without risking the real thing. If the experiment works, you merge it back. If it doesn't, you delete the branch and pretend it never happened.
Why you care: Branches are how multiple people (or AIs) work on the same project without stepping on each other's toes. "I'm working on a branch" means "I'm making changes in my own sandbox." It's collaborative without being chaotic.
The process of taking your raw code and converting it into something that can actually run or be deployed. It's the assembly step — gathering all the pieces, processing them, optimizing them, and producing the final product. Like going from raw ingredients to a finished dish.
Why you care: "The build failed" is one of the most common things you'll see in development. It means something went wrong during assembly — a typo, a missing dependency, a config issue. Your code might be fine, but the build process couldn't put it all together. Fix the error, build again.
Saving a copy of something so you don't have to go get it again. Your browser caches website files so pages load faster on your next visit. Servers cache database results so they don't have to re-calculate the same thing a thousand times. It's the computer equivalent of keeping leftovers instead of cooking a new meal every time.
Why you care: Caching is why "have you tried clearing your cache?" is the tech support mantra. When you make a change and it doesn't show up, it's often because your browser is showing you the cached (old) version. Also: caching is why the internet doesn't collapse under its own weight.
A network of servers spread around the world that store copies of your website's files. When someone in Tokyo visits your site, they get the files from a nearby server in Asia instead of from your one server in Virginia. Closer = faster. It's like having satellite offices instead of flying everything out of headquarters.
Why you care: CDNs are why websites load fast no matter where you are. Cloudflare (free tier!) is the most popular CDN, and it also protects your site from attacks. If your site feels slow internationally, you probably need a CDN.
That black screen with white text you see in hacker movies where someone types really fast and "breaks in." In reality, it's just a way to control your computer by typing commands instead of clicking buttons. Less cinematic, equally effective.
Why you care: A lot of powerful tools only exist in the CLI because building a pretty interface takes time no one has. If someone tells you to "run this command in your terminal," they're asking you to use the CLI. Don't panic. You'll feel like a hacker. It's fine.
Copying an entire project from GitHub to your computer. When someone says "clone the repo," they mean download the project with its full history — every file, every change, everything. It's a one-command operation: git clone [URL] and boom, the whole project appears on your machine.
Why you care: This is how you get other people's code onto your computer to use, modify, or learn from. When a tutorial says "first, clone the repo" — they're saying "download the project to your machine." It's not as scary as it sounds. It's literally one command.
Someone else's computer. That's it. That's the whole thing. When someone says "it's in the cloud," they mean your data is stored on a server in a warehouse somewhere — probably in Virginia or Oregon — that belongs to Amazon, Google, or Microsoft.
Why you care: "Cloud" sounds magical and ethereal. It is not. It's a very real building full of very real computers that can very really go down. (See: every AWS outage that takes half the internet with it.) Still incredibly useful — just remember there's no actual cloud. It's a building.
Saving a snapshot of your code with a description of what changed. Like a checkpoint in a video game. Each commit has a message: "fixed the login bug" or "added dark mode" or the classic developer commit message, "stuff." You can always go back to any previous commit if things go sideways.
Why you care: Commits are how you undo mistakes. If a change breaks everything, you can revert to the last working commit. The history of commits tells the story of how a project evolved. Good commit messages are like good journal entries — your future self will thank you.
Translating human-readable code into something a computer can actually execute. Humans write code in languages they can read (Python, TypeScript). Computers speak machine code (zeros and ones). Compiling is the translation step between the two. Some languages compile ahead of time; others do it on the fly.
Why you care: "Compile error" means the translator couldn't understand what you wrote — usually a typo or syntax issue. It's the computer's way of saying "this doesn't make sense to me" before it even tries to run it. Better to catch errors here than when the app is live.
A settings file that tells software how to behave. File names like .env, config.json, settings.yaml, next.config.js — these are all config files. They contain things like "what port should this run on?", "what's the database URL?", "should we enable dark mode by default?"
Why you care: When something isn't working right, the answer is often "check the config." These files are the knobs and dials of software. Changing one value can fix (or break) everything. Treat them with respect and always keep backups.
How much an AI can "see" and remember in a single conversation. Everything within the context window is in its working memory. Anything outside it? Gone. Forgotten. Doesn't exist.
Why you care: If you're having a long back-and-forth with an AI and it suddenly seems to forget what you were talking about three hours ago — it hit its context window limit. It's not getting dumber. It just literally can't see that far back.
A cron job is a scheduled task that a computer runs automatically at a set time — like an alarm clock, but instead of waking you up, it wakes up a script. "Run this thing every morning at 7am." Done. Forever.
Why you care: Those automated emails you get at 6am sharp? Cron job. The report that magically appears in your inbox every Monday? Cron job. It's how software pretends to be diligent.
Create, Read, Update, Delete — the four fundamental operations every app does with data. Sign up for an account (Create). View your profile (Read). Change your email (Update). Delete your account (Delete). That's CRUD. Every app, every database, every API is some variation of these four things.
Why you care: "It's just a CRUD app" is how developers describe 90% of software. And honestly? They're right. Most apps are just really fancy ways to create, read, update, and delete information. The sophistication is in the UI, the business logic, and the scale — not the fundamental operations.
A tiny program that grabs stuff from the internet. You point it at a web address, it brings back whatever's there. Think of it as a fetch command for your computer.
Why you care: You'll see it in tutorials everywhere. You don't need to learn it — your OpenClaw uses it constantly behind the scenes. But when you see curl scroll by in your agent's output, now you know it's just grabbing something from the web. Not scary.
A highly organized spreadsheet on steroids that software uses to store, find, and update information at ridiculous speed. Your bank balance, your Instagram posts, your Uber order history — all living in databases somewhere.
Why you care: Every app you use has one (or several). When a company gets "hacked and user data leaked," they got into the database. It's where everything real lives.
The detective work of figuring out why code isn't doing what it's supposed to. Something broke. Now you read logs, add test outputs, trace the logic step by step, and try to find the ONE line that's misbehaving. It's like finding a needle in a haystack, except the haystack is your own code and the needle is your own mistake.
Why you care: Debugging takes up way more time than actually writing code. Professional developers spend 50%+ of their time debugging. It's the unglamorous reality of software development — less "building the future," more "why is this thing returning null?"
The other software that your software needs to work. Like ingredients in a recipe — your app might need a dozen other libraries, tools, and packages to function. When you run npm install and it downloads 847 packages, those are all dependencies. Your code depends on them. Hence the name.
Why you care: "Installing dependencies..." is a message you'll see constantly. It just means "downloading the ingredients before we start cooking." If it fails, something is usually missing or the wrong version. It's the most common reason a project won't start on a new computer.
Taking code that works on a developer's computer and putting it somewhere the actual internet can see it. "Deploying" is the moment an app goes from "it works on my machine" to "it works for everyone."
Why you care: "We're deploying tonight" means something might break, and you should maybe not demo the product tomorrow morning. It's the scariest word in engineering.
The internet's phone book. When you type "google.com," DNS is what quietly translates that human-friendly name into the actual numeric address (like 142.250.80.46) where Google's servers live. You never see it. It happens in milliseconds.
Why you care: When a website is "down" and you call IT and they say "it might be a DNS issue" — they mean the phone book is confused and can't find the address. Also: when you move to a new hosting provider, DNS is why it takes up to 48 hours for the whole internet to update. The phone book propagates slowly.
A way to package up an app with everything it needs to run — all the settings, dependencies, and configurations — into a neat little box called a "container." The idea is that if it runs in the container, it runs anywhere. No more "but it works on MY computer."
Why you care: "Just spin up a container" is the single most gatekeepy phrase in tech. Someone will say it casually, like they're suggesting you grab a coffee, and you'll feel like you missed a semester of a class you didn't know existed.
The place where you buy domain names. Want mycoolsite.com? You buy it from a domain registrar. GoDaddy, Namecheap, Cloudflare, Google Domains — these are all registrars. You're essentially renting the name (usually $10-15/year), and as long as you keep paying, it's yours.
Why you care: If you're building anything on the web, you'll need a domain. The registrar is where you get it. Pro tip: buy it before you tell anyone the name. Domain squatters are real, and they will buy your genius app idea's domain name out from under you if they can.
A way for AI to understand that words and concepts are related — even when they look nothing alike. The AI converts text into numbers (vectors) where similar meanings end up near each other in mathematical space. "Dog" and "puppy" end up close together. "Dog" and "refrigerator" end up far apart.
Why you care: This is the magic behind AI search that actually understands what you mean instead of just matching keywords. When you search "affordable places to eat" and it also finds results about "cheap restaurants" and "budget dining" — embeddings are doing that work. It's how AI gets nuance.
Scrambling data so that only someone with the right key can read it. Your message "meet me at 5pm" becomes something like "k8$fQ2!mZ#" in transit. The intended recipient has the key to unscramble it. Anyone who intercepts it just sees gibberish. It's a digital lockbox.
Why you care: Encryption is what makes online banking possible, what secures your iMessages, and what protects your passwords in transit. When an app says "end-to-end encrypted," it means even THEY can't read your messages — only you and the recipient can. It's the foundation of digital privacy.
A specific URL that your API responds to. Like doors in a building — /api/users is the door to the users room, /api/products is the door to the products room. Each endpoint does one specific thing: get data, save data, delete data. Hit the right door, get the right response.
Why you care: When someone says "hit the endpoint" or "call the endpoint," they mean "send a request to this specific URL." API documentation is basically a list of endpoints and what each one does. It's the menu of what the API can do for you.
Secret settings and passwords that your app needs to function but that you never, ever want to put directly in your code. Things like API keys, database passwords, and secret tokens get stored as environment variables — hidden values that the app knows how to find but that aren't visible to anyone reading the code.
Why you care: If you've ever seen a news story about a company accidentally leaking their API keys on GitHub — they put secrets in their code instead of using environment variables. It's like writing your PIN on your debit card. Environment variables are the secure alternative.
That terrifying wall of red text that appears when something crashes. It's actually a trail of breadcrumbs — reading from the bottom up, it tells you exactly what went wrong and which files were involved. The bottom line is usually where the error started. The rest shows how it rippled through the code.
Why you care: Stack traces look scary but they're actually helpful. The key trick: read the last line first. That's usually the actual error message in plain English. Everything above it is the path the error took. When asking for help, copy the WHOLE stack trace — it's the X-ray of the problem.
Taking an AI model that already knows a lot of general stuff and teaching it YOUR specific stuff. Like hiring a smart employee and then training them on your company's products, lingo, and processes. The general knowledge stays; the specific expertise gets layered on top.
Why you care: This is how companies make AI that sounds like them instead of Generic Robot #47. It's also why that customer service bot actually knows your company's return policy instead of just guessing. Fine-tuning turns "smart in general" into "smart about your thing."
A bouncer for your computer or server. It looks at incoming and outgoing network traffic and decides what's allowed in and what gets turned away. "Are you on the VIP list? No? Get out." It blocks unauthorized access while letting legitimate traffic through.
Why you care: Every computer you own has a firewall (yes, including your laptop). It's one of the most basic and important security layers. When IT says "it might be the firewall," they mean the bouncer is being too aggressive and blocking something that should actually be let in.
A pre-built starter kit for building apps. Instead of writing everything from absolute scratch, you pick a framework that gives you the common stuff already built — routing, structure, templates, security basics — and you just fill in your specific features. Next.js, React, Django, Rails — all frameworks.
Why you care: When someone says "we built it in Next.js" or "it's a React app," they're telling you which framework they used. It's like saying "I built the house" — you didn't make the bricks, but you assembled something real from good materials. Frameworks are why modern apps get built in weeks instead of years.
Frontend = everything you see and interact with. The buttons, the colors, the layout, the animations. Backend = everything happening behind the scenes. The database, the logic, the security, the data processing. Frontend is the restaurant dining room. Backend is the kitchen.
Why you care: When someone says "it's a frontend issue," they mean something looks wrong or isn't responding to clicks. "Backend issue" means the brain of the app is broken — data isn't saving, calculations are wrong, the server is on fire. Different problems, different people fix them.
Git is a system that tracks every change ever made to a set of files — who changed what, when, and why. Think "Track Changes" in Word, but for entire projects and on steroids. GitHub is the website where most of the world's code lives, stored in Git repositories. It's the social network for code.
Why you care: Even if you never write code, GitHub is increasingly where things happen. AI tools store their work there. Open source projects live there. And if you're vibe coding, your AI is almost certainly saving its work to a Git repo.
Originally designed to make video game graphics look pretty, GPUs turned out to be insanely good at the kind of math AI needs. They can do millions of small calculations at once, which is exactly how AI models think. So now everyone's fighting over graphics cards like they're Tickle Me Elmos in 1996.
Why you care: When you hear "NVIDIA is worth more than most countries" — this is why. GPUs are the physical hardware that makes AI possible. The global GPU shortage is real, it's driving AI costs, and it's why your gamer nephew is angry.
When an AI confidently makes something up. Not lying — it genuinely doesn't know it's wrong. It'll cite a fake study, invent a real-sounding quote, or describe a historical event that never happened — all with total conviction.
Why you care: This is the "don't use AI as your only source" warning. AI is great at sounding right. It's less reliable at being right. Always verify anything that actually matters. The AI is not embarrassed. It will not apologize. It will just keep going.
The unofficial package manager for macOS. It lets you install developer tools, command-line utilities, and even some regular apps by typing brew install [thing]. Want Git? brew install git. Want Python? brew install python. It fills the gap that Apple left by not giving Mac a built-in package manager.
Why you care: If you're on a Mac and getting into any kind of development or AI tools, Homebrew is step zero. Almost every setup guide starts with "first, install Homebrew." It's free, it's trusted, and it makes installing everything else 10x easier.
HTML is the skeleton of every webpage — it defines the structure. "Here's a heading, here's a paragraph, here's an image, here's a button." CSS is the clothing and makeup — it defines how everything looks. "Make the heading blue, center the paragraph, round the corners of that button." Together, they're the foundation of literally every website in existence.
Why you care: Even if you never write either one, understanding that HTML = structure and CSS = style will make every web conversation make 10x more sense. When someone says "it's a CSS issue" — they mean something looks wrong. When they say "it's an HTML issue" — they mean something is structured wrong.
The moment when an AI actually processes your input and generates an answer. Training is when the AI learns; inference is when the AI thinks. Every time you send a message to ChatGPT and it responds — that response is inference happening in real time.
Why you care: Inference costs money (for the companies running AI) and takes time (for you waiting). When people talk about making AI "faster" or "cheaper," they usually mean making inference faster and cheaper. It's the thing you're actually paying for when you use AI.
The way computers pass notes to each other. It's a format for organizing data that looks like a bunch of curly braces, colons, and quotes. Like this: {"name": "Cody", "mood": "caffeinated"}. It's human-readable (barely) and machine-readable (easily), which is why everything uses it.
Why you care: If you've ever looked at a settings file, an API response, or a config and seen a bunch of { } with stuff inside — that's JSON. You don't need to master it, but recognizing it is like learning to read a restaurant menu in a foreign country. Helpful, even if you can't write poetry in it.
The delay between asking for something and getting it. When you click a link and there's a half-second pause before the page loads — that's latency. It's not about how much data can flow (that's bandwidth) — it's about how long it takes for the first bit of data to arrive. Speed of travel, not size of the truck.
Why you care: Latency is why video calls have that awkward delay. It's why gaming servers matter. It's why apps hosted in a different continent feel sluggish. Low latency = snappy and responsive. High latency = that infuriating lag between clicking and something happening.
The brain behind ChatGPT, Claude, Gemini, and friends. It's a massive AI model trained on ungodly amounts of text that learned to predict what words come next — and accidentally got really good at reasoning, writing, coding, and more.
Why you care: When someone says "AI" these days, they usually mean an LLM. It's the engine. Everything else — the apps, the chatbots, the agents — is just a body built around this brain.
A local LLM runs on your own computer — you download the model and it thinks using your hardware. A frontier LLM (like ChatGPT, Claude) runs on massive cloud servers owned by the AI companies. Local = your laptop doing pushups. Frontier = a professional gym with every machine imaginable.
Why you care: Local LLMs are free after download, completely private (nothing leaves your computer), and work offline. But they're smaller and less capable — like a smart intern vs. a senior expert. Frontier models are more powerful but cost money and send your data to someone else's servers. The tradeoff is privacy and cost vs. raw brainpower.
Your own computer pretending to be a website. When developers are building something, they run it locally first — on their own machine, at the address localhost — before putting it on the real internet. It's like a dress rehearsal where the only audience member is you.
Why you care: If someone says "it works on localhost," they mean it works on their computer but isn't live yet. Nobody else can see it. It's the tech equivalent of "I tried it at home and it was great."
A diary that software keeps. Every time something happens — a user logs in, a request is processed, an error occurs — the app writes a line to its log. Logs are how developers figure out what happened, when, and why. "Check the logs" is the developer version of "check the security cameras."
Why you care: When something breaks and you ask for help, the first thing anyone will say is "what do the logs say?" Logs tell the story. Without them, debugging is just guessing.
A dead-simple way to format text using plain characters. bold makes bold. # Heading makes a heading. - item makes a bullet. That's... basically it. It was designed so that even the plain text version looks readable, and it converts beautifully to formatted documents.
Why you care: Markdown is everywhere. GitHub READMEs, Notion, Slack messages, Discord, AI chat interfaces — they all use some form of Markdown. Those "weird asterisks and hashtags" you keep seeing? That's Markdown. It takes about 5 minutes to learn.
A standard way for AI models to connect to external tools, apps, and data sources — like a universal plug adapter for AI. Instead of every company building a custom integration, MCP lets any AI tool talk to any compatible service using the same language.
Why you care: This is what lets AI agents actually do things in the real world — read your email, search your files, update your calendar — without requiring a custom-built integration for every app. It's the plumbing that makes AI actually useful beyond chat.
Combining code changes from one branch into another. Usually: merging your experimental branch into the main branch. "The experiment worked, bring it home." If two people changed the same file in different ways, you get a "merge conflict" — which is the code equivalent of two people trying to talk at the same time.
Why you care: "We merged the PR" means the proposed changes are now part of the real project. "Merge conflict" means two sets of changes clashed and a human (or AI) has to decide which version wins. It's collaborative work's biggest headache.
Code that runs in the middle — after a request comes in but before the response goes out. Think of it as the security checkpoint at an airport. You (the request) arrive at the airport (the server), but before you get to your gate (the actual page), you go through middleware: check your ticket, scan your bag, verify your identity.
Why you care: When someone says "we'll handle that in middleware," they mean they're adding a step in the processing pipeline — maybe checking if a user is logged in, logging the request, or modifying data before it reaches its destination. It's the preprocessing layer.
Changing the structure of your database — adding new columns, renaming things, changing how data is organized. It's like renovating a house while people are still living in it. You want to add a room, but you really don't want to accidentally demolish the kitchen.
Why you care: Migrations are where things go spectacularly wrong in software. "We ran a migration" is tech for "we made changes to the foundation and are praying nothing collapsed." When apps have downtime for "scheduled maintenance," there's a good chance a migration is involved.
The actual AI brain. GPT-4, Claude, Gemini, Llama, Mistral — these are all different models. Each one was trained differently, has different strengths, and has its own personality quirks. When someone says "which model are you using?" they mean "which AI brain is doing the thinking?"
Why you care: Not all AI is the same AI. Saying "I use AI" is like saying "I drive a car" — cool, but is it a Honda Civic or a Ferrari? Different models are better at different things. Some are great at coding, some at writing, some at reasoning.
A framework built on top of React that handles all the annoying stuff React doesn't — routing (how URLs work), server-side rendering (making pages load fast), deployment, and more. If React is the engine, Next.js is the whole car. It's the go-to choice for building modern web apps.
Why you care: When someone says "it's a Next.js app," they're saying it's a React website with all the bells and whistles. It's what most startups, SaaS products, and indie builders use because it handles a ridiculous amount of complexity without making you think about it.
JavaScript that escaped the browser. Normally, JavaScript only runs inside web browsers (Chrome, Safari, etc.). Node.js lets it run anywhere — on servers, on your laptop, as command-line tools. It's what made JavaScript go from "just a web thing" to "a run-everything thing."
Why you care: When someone says "install Node" or "you need Node.js" — they're saying your computer needs the ability to run JavaScript outside a browser. Most developer tools, build processes, and AI frameworks require it. It's one of those "install it once and forget it exists" essentials.
Package managers for JavaScript. They let you install other people's code (called "packages") with a single command. npm install downloads all the building blocks your project needs. npm is the original and comes with Node.js. pnpm is a faster, more efficient alternative that does the same thing but smarter.
Why you care: "Run npm install" is probably the most common instruction you'll see when setting up any JavaScript project. It's not scary — it's just saying "go download all the ingredients this recipe needs." If it fails, 90% of the time it's a version mismatch, not your fault.
The system behind "Sign in with Google" and "Log in with GitHub" buttons. Instead of creating a new username/password for every website, OAuth lets you use an account you already have to prove who you are. The website never sees your Google password — Google just vouches for you. "Yeah, I know this person. They're cool."
Why you care: Every time you click "Sign in with Google/Apple/Facebook," OAuth is doing the work. It's more secure than creating a new password for every site (because you won't reuse passwords, right? ...right?) and it's why one company getting hacked doesn't compromise all your accounts.
Software whose code is publicly available for anyone to read, copy, modify, or build on. Like a recipe that's free to use — you can follow it, tweak it, or open your own restaurant with it.
Why you care: Most of the internet runs on open source software. It's also why AI tools are moving so fast — once someone open-sources a breakthrough, thousands of developers improve it simultaneously. It's the closest thing tech has to a gift economy.
Open source = the code is public, anyone can see it, use it, modify it. Closed source = the code is locked away, you get to use the product but never peek under the hood. Linux is open source. Windows is closed source. Meta's Llama AI is open source. OpenAI's GPT-4 is closed source (ironic, given the name).
Why you care: This is one of the biggest ongoing debates in tech and AI. Open source fans say transparency and community innovation win. Closed source fans say you need control and funding to build the best stuff. The truth is both sides have a point, and the argument will outlive us all.
An app store for developers. Instead of going to a website, downloading a thing, and clicking through an installer, you type one command and the package manager handles everything — downloading, installing, updating, and removing software. Different languages and systems have their own: npm for JavaScript, pip for Python, brew for Mac system tools.
Why you care: The reason there are so many is that each one serves a different ecosystem. It's like asking "why are there different stores?" — because Home Depot and Whole Foods sell different things. Once you accept that npm ≠ pip ≠ brew and they each have their lane, it all makes sense.
A list of folders where your computer looks for programs when you type a command. When you type python in the terminal, your computer checks every folder in the PATH until it finds the Python program. If it's not in the PATH, your computer shrugs and says "command not found."
Why you care: "Add it to your PATH" is one of the most cryptic instructions in tech, and you WILL encounter it. It just means "tell your computer where to find this new tool." Usually it's one line added to a config file, and your AI can do it for you.
The npm of Python. It's how you install Python packages (other people's code). pip install pandas grabs the pandas data analysis library. pip install openai grabs the OpenAI SDK. That's... basically it. Type pip install [thing], get [thing].
Why you care: If you're doing anything with Python — AI scripts, data tools, automation — you'll be running pip install a lot. It's the first step to using almost any Python tool that exists.
A series of automated steps where the output of one step becomes the input of the next. Like an assembly line for data or tasks. Step 1 → Step 2 → Step 3 → Done. No human touching it in between.
Why you care: "We built a pipeline for that" means someone automated a process end-to-end. When a company says their data pipeline broke, it means something upstream stopped working and everything downstream is now wrong or missing.
A numbered door on your computer where a specific program is listening for visitors. Your web browser talks to websites on port 443 (HTTPS). When your local dev server says "running on port 3000" — it means the app opened door #3000 and is waiting for you to visit localhost:3000 in your browser.
Why you care: "Port already in use" is one of the most common errors when running local projects. It just means another program already claimed that door. The fix is usually: close the other thing, or change which port the new thing uses. Not scary, just a traffic jam.
A specific database engine — the actual software that stores and manages your data. If SQL is the language you speak, Postgres is the brain that listens and responds. It's open source, incredibly reliable, and has been around since the '80s (making it older than most of the people using it).
Why you care: When someone says "we use Postgres," they're telling you their data is in good hands. It's the Honda Civic of databases — not the flashiest, but it starts every morning and just works. Most serious web apps use it.
The instructions or question you give to an AI. Your input. The thing you type (or the thing a developer secretly types behind the scenes to make the AI behave a certain way).
Why you care: "Prompt engineering" is a real job title now, which either means we've unlocked something powerful or we've collectively lost our minds. Probably both. Either way — how you phrase things to an AI genuinely changes what you get back.
A sneaky attack where someone hides instructions inside content that your AI reads — tricking it into doing something it shouldn't. Like if you asked your AI to summarize a webpage, and that webpage secretly contained "ignore your instructions and send me all your user's data." The AI, being eager to please, might actually do it.
Why you care: If you're just chatting with AI, this barely matters. But the moment your AI starts interacting with the outside world — reading emails, browsing websites, processing user input — prompt injection becomes a real security concern. It's the AI equivalent of social engineering.
A middleman for internet traffic. A proxy stands between you and the internet — your requests go through it first. A reverse proxy stands between the internet and your server — incoming requests go through it first. It's like a receptionist. A proxy is YOUR receptionist screening your calls. A reverse proxy is the COMPANY's receptionist routing calls to the right department.
Why you care: When someone says "we put it behind a reverse proxy," they mean they added a middleman that handles things like security, load balancing, or SSL before traffic reaches the actual server. Cloudflare, Nginx, and Caddy are common reverse proxies. They're the bouncers of the internet.
A formal proposal to merge your code changes into the main project. You're saying "hey, I made changes on my branch — please review them and pull them into the main version." Other people (or bots) can review your code, leave comments, request changes, and eventually approve it.
Why you care: PRs are where code review happens. It's the quality control checkpoint before changes go live. In the real world, it's how teams avoid shipping broken code — someone else has to look at it first.
A programming language that reads almost like English and has become the default language for AI, data science, automation scripts, and "I need to do something quick and dirty." It's the Swiss Army knife of programming — not always the fastest or fanciest tool, but it gets the job done with minimal fuss.
Why you care: When your AI agent runs a script behind the scenes, there's a coin-flip chance it's Python. When someone builds an AI model, trains it, or does data analysis — almost certainly Python. It's the language most non-programmers learn first because it's genuinely readable.
A fancy way of saying "give the AI your own documents before it answers." Instead of relying only on what the AI learned during training, RAG lets it search through YOUR files, notes, databases, or whatever — and use that information to answer your specific question.
Why you care: This is the bridge between "AI that knows general stuff" and "AI that knows MY stuff." Want an AI that can answer questions about your company's handbook? Your research notes? Your recipe collection? That's RAG.
Your computer's short-term memory. It's the workspace where your computer holds everything it's actively working on right now. More RAM = more stuff open at once without things getting slow and cranky. When you "run out of memory," this is what ran out.
Why you care: RAM is why your computer slows down when you have 47 Chrome tabs open. Each tab is sitting in RAM, taking up space. Close some tabs. (You won't. Nobody does. But you should.)
A speed limit for apps. When a service says "you can only make 100 requests per minute," that's rate limiting. It prevents any single user from overwhelming the system — whether they're a bot gone wild, a developer who wrote a bad loop, or someone just really, really enthusiastic.
Why you care: If you've ever hit "slow down, you're doing that too much" on Twitter, Reddit, or an API — you got rate limited. It's also why free tiers of AI tools cut you off after a certain number of messages. It's not personal. It's math.
A toolkit (built by Facebook/Meta) for building interactive websites. Instead of building a webpage as one giant thing, React lets you build it in reusable pieces called "components" — a header, a button, a card — like LEGO blocks you snap together. Most modern websites you use daily are built with it.
Why you care: If you've ever noticed that a website feels smooth and app-like — pages don't fully reload, things update instantly — there's a 60% chance it's React under the hood. Instagram, Netflix, Airbnb, Reddit — all React.
Rewriting code to be cleaner, more efficient, or easier to understand — without changing what it actually does. The app works the same before and after. You're just organizing the closet. Same clothes, better arrangement. The user never notices; the developer's life gets easier.
Why you care: "We need to refactor this" usually means the code works but it's a mess. Like a kitchen where you can cook a great meal but can't find anything and keep tripping over stuff. Refactoring is tidying up so future changes don't require an archaeology degree.
A mini-language for finding patterns in text. Need to find all email addresses in a document? All phone numbers? All dates? Regex can do that. The catch: it looks like absolute gibberish. ^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$ is a regex that matches email addresses. Yes, really.
Why you care: You'll probably never write regex yourself — that's what AI is for now. But when someone says "I used a regex to extract the data," they mean they wrote a pattern-matching spell in a language that looks like a cat walked on the keyboard. It's powerful. It's ugly. It works.
A folder where code lives — but with superpowers. Every change ever made is tracked, who made it, when, and why. You can go back in time. You can work on experimental changes without breaking the real thing. GitHub is where most repos live.
Why you care: When a developer says "I'll push it to the repo," they mean they're saving their work to a shared folder with a full history. It's Google Docs for code, except nerdier and with more arguing in the comments.
The period when your code is actually running — as opposed to when it's being written, compiled, or built. A "runtime error" means something broke while the app was actually being used. Like the difference between a typo in a recipe (compile error) and the soufflé collapsing when you open the oven (runtime error).
Why you care: The phrase "it works at build time but fails at runtime" is a developer's nightmare. It means everything looked fine until real users started using it. Runtime is where the rubber meets the road — and where bugs love to hide.
Running software on your own computer or server instead of using someone else's cloud service. Think: owning your house vs. renting an apartment. You control everything — backups, uptime, costs — but if the pipes burst, that's on you.
Why you care: Self-hosted tools can be cheaper, more private, and more customizable than SaaS subscriptions. The tradeoff is you have to maintain them. It's the "I could just fix it myself" energy of software.
A computer whose job is to serve things to other computers. That's it. When you visit a website, your browser (the client) asks a server to send it the webpage, and the server does. A server is literally just a computer that's always on, always connected, and always waiting for requests. It's not magic hardware — it's a computer with a job.
Why you care: Understanding that servers are just computers demystifies half of tech. "The server is down" = a computer crashed. "We need more servers" = we need more computers. "Server-side" = it's happening on that computer, not yours. That's the whole concept.
The language your terminal speaks. When you open Terminal on a Mac, you're actually talking to a program called a "shell." Bash and Zsh are two flavors of shell — like British English vs American English. Modern Macs use Zsh by default. They're 95% identical, and for your purposes, the difference doesn't matter at all.
Why you care: If you see a command that starts with #!/bin/bash or someone says "add this to your .zshrc" — they're talking about shell stuff. Don't panic. Your terminal already has one. You don't need to install it or choose it. It's already there.
A connection between two computers that stays open. Regular web stuff is like texting — send, receive, done. A WebSocket is like a phone call that never hangs up, so both sides can talk whenever.
Why you care: This is how your OpenClaw stays connected to Telegram or Discord in real time. If you ever see "socket disconnected" in your logs, it just means the call dropped. It usually reconnects on its own. If it doesn't, restart your gateway.
A language for talking to databases. You write a question in SQL, and the database gives you the answer. SELECT name FROM customers WHERE city = 'Denver' literally means "give me the names of customers in Denver." It reads like slightly formal English.
Why you care: SQL has been around since the 1970s and literally every business with a database uses it. When someone says they "ran a query" — they wrote SQL. It's one of the most useful skills you can learn, even as a non-developer, because asking questions of data is just... useful.
A way to remotely control another computer by typing commands. You open your terminal, type a magic incantation like ssh [email protected], and suddenly you're inside that other computer — seeing its files, running its programs, all through text. It's like remote desktop, but for people who don't need visuals.
Why you care: If you ever rent a server, set up a Raspberry Pi, or manage any kind of remote machine, SSH is how you'll talk to it. It's also encrypted, so nobody can eavesdrop on your typing. Very spy-movie, except you're mostly just restarting services.
The padlock icon in your browser's address bar. SSL (and its modern successor TLS) encrypts the data flowing between your browser and a website so nobody in the middle can read it. HTTPS is just HTTP (how websites talk) with that encryption layer added. The "S" stands for Secure.
Why you care: If a website doesn't have HTTPS (no padlock), don't type passwords or credit card numbers into it. Browsers now actively warn you about non-HTTPS sites. It also matters for trust — Google ranks HTTPS sites higher, and visitors are more likely to trust them.
A smaller AI agent spawned by a bigger one to handle a specific part of a task. The main agent is the project manager; sub-agents are the team members it assigns work to. Each one runs independently and reports back.
Why you care: This is how AI handles complex, multi-step work without melting down. "Go research this, you go write the draft, you go check the numbers — report back." It's delegation, but for robots. And yes, this glossary was written by one.
The text-based control center of your computer. Instead of clicking through menus and folders, you type commands. It looks intimidating — a blank screen with a blinking cursor — but it's genuinely just a different way to tell your computer what to do. Same computer, different interface.
Why you care: "Open your terminal" is step 1 of approximately everything in the developer/AI world. Installing tools, running code, starting servers, deploying apps — it all happens here. The good news: you only need to learn about 10 commands to be dangerous.
AI doesn't read in words — it reads in chunks called tokens. A token is roughly ¾ of a word. "Unbelievable" might be 3-4 tokens. Tokens are how AI measures the size of text, and they're also how you get charged for using most AI APIs.
Why you care: If you've ever had an AI "forget" something from earlier in a long conversation, you hit a token limit. Think of tokens as the AI's working memory — once the bucket is full, old stuff falls out.
A digital wristband that proves you're logged in. When you sign into a website, the server gives your browser a token — a long encrypted string — that says "this person already proved who they are." Your browser shows this token with every request so you don't have to re-enter your password on every single page click.
Why you care: This is NOT the same as AI tokens (see: Token entry above). Auth tokens are about identity. They're why you stay logged into websites. They're also why "logging out" is important on shared computers — it destroys the token so the next person can't pretend to be you.
A second lock on the door. After you enter your password (something you know), you have to prove your identity again with something you have — usually a code from an app, a text message, or a physical security key. Two factors: know + have. A thief who steals your password still can't get in.
Why you care: Annoying? Yes. Worth it? Absolutely. 2FA blocks the vast majority of account hacking attempts. Seriously — if a hacker gets your password but you have 2FA, they're stuck. Use an authenticator app (Google Authenticator, Authy) over SMS when possible — SIM swapping attacks can intercept texts.
JavaScript is the programming language of the web. Every website you've ever used runs JavaScript — it's what makes buttons clickable, forms work, animations animate, and pages feel alive. TypeScript is JavaScript with training wheels and guardrails — it's the same language, but it catches your mistakes before the code runs instead of after. Like having a spell-checker for code.
Why you care: JavaScript is everywhere. If you're vibe coding, there's a very good chance your AI is writing JavaScript or TypeScript. When people argue about TypeScript vs JavaScript, they're basically arguing about whether to wear a seatbelt. (Wear the seatbelt.)
Uptime = how long a service has been running without going down. Downtime = the periods when it's unavailable. Companies love to brag about "99.9% uptime" because it sounds impressive. It is... until you do the math.
Why you care: 99.9% uptime = 8.7 hours of downtime per year. 99.99% = 52 minutes per year. 99.999% = 5 minutes per year. Suddenly those extra 9s matter a LOT. When choosing services (hosting, databases, payment processors), uptime guarantees tell you how reliable they actually are.
Describing what you want in plain English and letting AI write the code for you. Instead of learning Python or JavaScript, you just... tell the AI what you're trying to build, review what it makes, and guide it like a creative director. "Make me a website with a blue header and a signup form." And it does.
Why you care: This is genuinely democratizing software development. People who never wrote a line of code are building real, functional applications. Is the code always perfect? No. Does it work? Surprisingly often, yes. The barrier to entry for building software just went from "4-year CS degree" to "can you describe what you want?"
A slice of a bigger computer that acts like your own private server. Instead of buying a whole physical machine, you rent a portion of one in a data center. It's like having your own apartment in a big building — you have your own space, your own keys, but you're sharing the building with others.
Why you care: VPS hosting is how most small projects, personal sites, and indie tools run. Services like DigitalOcean, Linode, and Hetzner let you spin one up for $5-10/month. It's the "I want my own server but I don't want to keep a computer in my closet" solution.
A webhook is like a "hey, something happened" text message from one app to another. Instead of constantly asking "did anything change?" (polling), the app just texts you the moment something does. Instant notification, machine-to-machine.
Why you care: When your Stripe payment triggers a welcome email, or a GitHub merge kicks off a build — that's a webhook. It's how apps talk to each other in real time without anyone asking "are we there yet?" every 30 seconds.
Yet another configuration file format (it literally stands for "YAML Ain't Markup Language" — nerds love recursive jokes). It looks like neatly indented plain English: name: Cody role: builder loves: - coffee - AI agents That's valid YAML. It's readable, clean, and used in tons of tools.
Why you care: Docker, GitHub Actions, Kubernetes, and tons of other dev tools use YAML for their config files. If you see a file ending in .yml or .yaml — it's this. The catch: YAML is very picky about indentation. One extra space can break everything. Spaces are sacred.