Keywords bank
Every term the course defines, in plain language. Grows as more lessons land.
- Absolute path
- A path written as the full route from the root, e.g. `/Users/maya/Desktop/site/index.html`. Like a full postal address: it points to the same place no matter where you currently are.
- Acceptance criteria
- A short, explicit checklist of what 'done and usable' means for a deliverable (e.g. 'under one page, every fact from my notes, no invented stats'). It steers the AI and gives you an objective ruler to review against instead of a vague gut feeling.
- Accountability gap
- The problem that when AI 'decides' something and it goes wrong, the AI can't be held answerable — it has no licence to lose, no duty of care, no consequences. A human always has to own the outcome. The principle: automation can earn autonomy, but accountability never leaves the human.
- Agent
- An AI that doesn't just answer — it acts. Technically, a large language model placed in a loop where it can use tools to take actions toward a goal, observe what happened, and decide its next step, repeating until done. Contrast with a chatbot, which answers once and stops.
- Agent loop
- The repeating cycle that makes something an agent: perceive the situation → decide the next step → act (use a tool) → observe the result → repeat. Each observation feeds the next decision, so the agent can course-correct instead of stopping at its first attempt.
- AI toolkit
- A small, deliberately curated set of AI tools plus the reusable setup around them — saved prompts, a personal system prompt, projects, and templates — that you maintain over time. The opposite of a folder of bookmarks: it makes tools produce your work fast without re-explaining yourself.
- Argument
- The thing a command acts on — usually a file or folder name. In `cd projects`, `projects` is the argument: the folder you're telling `cd` to move into.
- Artifact
- In Claude, a self-contained piece of work — like a runnable mini-app — that appears in its own side panel instead of as chat text, and that you can use and share with a link.
- Artifact / Canvas
- A dedicated side panel where a document, table, or small app the AI makes lives next to the chat, so you can edit and re-edit it in place. Claude calls it an 'artifact'; ChatGPT calls it 'canvas'.
- Artifact workspace
- A side panel in tools like ChatGPT (Canvas) or Claude (Artifacts) where a deliverable lives as an editable document you refine in place, instead of it scrolling away in the chat history. Use it when the output is a real document or piece of code.
- Automation bias
- The human tendency to defer to a confident automated suggestion even when your own knowledge says otherwise. It's why a casual glance at AI output often rubber-stamps it instead of catching the error — documented in aviation, medicine, and the military.
- Autonomy
- How much an agent acts on its own without checking in with you at each step. More autonomy means faster, less hand-holding — and higher stakes, because a wrong step can be built on by the next one before you notice.
- Backend
- The behind-the-scenes part of an app you don't see — where data is stored and processed (for example, saving who voted). Tools like Lovable and Replit Agent can build this for you too, not just the frontend.
- Bias
- AI output reflects the average of its training data, including its skews. Average is not the same as good, fair, or true.
- Browser
- The program a user runs to use the web (Chrome, Safari, Firefox). The frontend runs inside it, on the user's own device — which is why what you see is separate from where the backend runs.
- Bug
- Any case where a program does something other than what you intended. Not a catastrophe and not a sign you're bad at this — every program ever shipped had bugs; building software is mostly finding and closing the gap between what you meant and what it does.
- Calibrated judgment
- Neither 'use AI for everything' nor 'avoid AI'. It's defaulting to AI while keeping a small, sharp set of triggers where you deliberately don't use it — or use it only in a bounded, advisory way with a human owning the outcome.
- Chat assistant
- A general-purpose AI app you talk to in plain language — ChatGPT, Claude, or Gemini. They're roughly interchangeable Swiss-army knives built on an LLM; knowing one well is enough.
- Column
- One category of information running down a table, the same idea as a spreadsheet column — for a to-do app, things like the task text, whether it's done, and who it belongs to.
- Command
- One line you type to tell the computer to do one thing — a verb you type instead of click, like 'show me what's in this folder' or 'go into that folder'. You press Enter to send it, exactly like sending a chat message.
- Command line
- The way of working where you interact with a computer by typing lines of text rather than pointing and clicking. People say 'the command line' and 'the terminal' to mean the same everyday experience.
- Comment
- A note humans write for humans inside code, which the computer ignores. In many languages it starts with // or #. Comments are often the fastest plain-English clue to what a confusing block is for.
- Confidence ≠ correctness
- The key safety rule: how sure an AI sounds tells you nothing about whether it's right. Fluency is not evidence.
- Config
- Configuration: settings rather than logic — keys and values, like a preferences screen written as text (for example package.json or a .env file). It tells you what and where, rarely how.
- Console
- A tool's behind-the-scenes log of what it did and what went wrong. The red error lines there often name the real cause far more precisely than 'it's broken' ever could.
- Context
- The background you give the AI about your situation — who it's for, what you have, the constraints. It can't see any of this unless you say it.
- Context isolation
- Each subagent works in its own fresh context, and only its conclusion comes back. The clutter it generated stays sealed inside it, so the main agent's working memory never gets polluted.
- Context rot
- The tendency for an AI to use information less reliably as the conversation gets very long — attention thins out across a big pile of text. More context is not automatically better; keeping it relevant matters.
- Context window
- The fixed-size 'desk' of working memory an AI spreads the current conversation on. It re-reads everything on this desk each turn. It has a limit — in long chats the oldest text falls off the edge and is forgotten.
- Coordination overhead
- The extra effort and cost of using subagents: splitting the work well, writing a clear brief for each, and stitching results back together. If a task is small or its steps are tightly chained, this overhead can outweigh the benefit.
- Cross-check
- Confirming a claim against more than one independent source. A real fact tends to show up in several places; something you can only find in one unverifiable place is a red flag.
- Ctrl-C
- Holding Ctrl and pressing C to cancel whatever command is currently running and get a fresh prompt back. Your eject button when something hangs or runs away.
- Database
- Where an app's data is stored so it survives — close the browser, come back tomorrow, your saved items are still there. The app's long-term memory. Covered in depth in its own lesson.
- Debugging
- The deliberate loop of finding and fixing a bug: reproduce it reliably, write down what you did / expected / got / the exact error, isolate the smallest case, guess a cause, test one change, observe, and verify the fix. A calm procedure, not a talent.
- Delegation
- Handing a piece of a job to a separate subagent instead of doing it all in one agent — like a manager assigning a task to a specialist rather than doing everything personally.
- Dependencies
- Outside code libraries a project needs in order to run. They're listed in `package.json` and the actual downloaded copies live in the `node_modules` folder.
- Dependency
- A piece of code your project needs in order to run, that the project itself didn't write — borrowed code (for drawing buttons, handling dates, talking to a database, and so on). Real projects have hundreds.
- Deploy
- Publishing your app so it's live on the internet at a real link other people can open. Most vibe-coding tools do this in one click.
- Deterministic
- Always giving the exact same output for the same input (like a calculator). An LLM is NOT deterministic — ask the same thing twice and the wording differs.
- Deterministic vs probabilistic
- Deterministic means the same input always gives the exact same output (ordinary code, a strict rule — like a calculator). Probabilistic means likely-but-varying output (an AI model predicting text). Workflows put deterministic checks between probabilistic AI steps.
- Diff
- A before/after view of exactly what changed in a file, usually showing removed lines in red and added lines in green. When the AI proposes an edit, reading the whole diff is how you confirm it changed only what you asked and didn't wander.
- Directory
- The technical word for a folder — a container that holds files and other folders. 'Change directory' (`cd`) just means 'go into that folder'.
- Domain/URL
- The web address people type to reach your live project. Hosting platforms give you a free working one (like your-app.vercel.app); a custom domain (like myidea.com) is one you buy and point at the same project — a polish step, not a requirement for shipping.
- Doom loop
- When you and the AI ping-pong with no progress — 'still broken' → it changes something → 'still broken' — for several rounds. The tell is rounds that add no new information. Breaking it needs a deliberate move, not another 'still broken'.
- Entry point
- The file a program starts running from — its front door. Often named main, index, app, or server, or named inside a config file. Everything else is reached from there, so finding it orients the whole codebase.
- Environment
- The whole surrounding setup code assumes in order to run: which dependency versions, which language version, which settings. Two computers with slightly different environments can run identical code differently — that's why 'it works on my machine' happens.
- Environment variable
- A named value (like OPENAI_API_KEY) you set in the hosting platform's settings, outside your code, which your code then reads by name when it runs. It's how a secret value stays out of your code and your repo while the app can still use it.
- Error message
- The red text a program shows when it gets confused. A clue, not a verdict — it usually names a file, a line, and the thing it couldn't do. The single best habit is to stop and actually read it, and to capture it exactly rather than skip past it.
- Evaluation (eval)
- A small set of test cases the output must pass before you trust it. Pick a few inputs where you already know the right answer, run the agent, and confirm it gets them right — if it fails the cases you can check, you can't trust the ones you can't.
- Few-shot (example-giving)
- Showing the AI one or two examples of what you want. One example is worth a paragraph of description, because pattern-matching is what it does best.
- Flag
- A setting added to a command that changes how it behaves, written with a dash, like `-l` or `--help`. One-letter flags use one dash, whole-word flags use two; short ones can be stacked (`-la`).
- FOMO learning
- Studying new things 'just in case' out of fear of missing out, because everyone is talking about them. It rarely sticks and the queue never ends. The sustainable opposite is learning on demand: going deep only when a real task in your actual work needs it.
- Frontend (UI)
- The part of an app you actually see and interact with — buttons, text, layout, the screen itself. 'UI' stands for user interface. Tools like v0 focus mainly on making this look good.
- Function
- A named recipe in code. It has a name saying what it does, takes ingredients in (parameters), runs steps, and produces a result. You can tell what a function is for from its name and shape without following every step inside it.
- Git
- The most widely used tool that performs version control. It records the project's change history inside the hidden `.git` folder. AI/vibe-coding tools turn it on automatically; you do not need to learn its commands to navigate a repo.
- Global vs local install
- A local install puts code inside one project's own folder — disposable, delete-and-redo, touches nothing else. A global install puts it system-wide, shared by everything and hard to undo. Prefer local; be suspicious of global.
- Ground truth
- The known-correct answer you check the agent against — the real number, the actual source document, a result you can work out independently. Without it you're only checking whether the output sounds right.
- Guardrail
- A limit you put around an agent so its mistakes stay cheap and recoverable: restricting what it can do, being able to interrupt and steer it, running it in a safe sandbox or test branch, and checking its output against something concrete.
- Hallucination
- When an AI gives a confident answer that is plausible-sounding but actually wrong, because it generates likely text rather than retrieving verified facts.
- Harness
- The ordinary program wrapped around the model — the app, chatbot backend, or agent framework. It actually executes the tool calls the model requests, returns results to the model, and can gate risky actions behind your approval.
- High-leverage task
- A task worth automating because it scores on all three of: frequent (you do it often), time-consuming (it eats real minutes), and AI-suitable (mostly drafting/transforming/summarising/researching/checking). Improving it pays back every time the task recurs.
- Hosting
- A service that runs an always-on server for you and handles the unglamorous parts (keeping it on, traffic, the https security certificate) so you just point it at your code. Vercel and Netlify are common examples; a vibe-coding tool's one-click Publish button is the same thing with the wiring hidden.
- Human-in-the-loop
- A checkpoint where an agent pauses and waits for a person to approve before it does something consequential or irreversible — send, pay, delete, publish. Reversible work can run free; one-way doors get a human hand on them.
- Hype
- Claims engineered to sound revolutionary, often by people who benefit from you believing them. Read it like any confident AI output: what is the specific checkable claim, who benefits, and has anyone independent used it on real work?
- Hypothesis
- A specific, testable guess at the cause of a bug ('I think the Save button calls a function that was never created'). You test one hypothesis by changing one thing and observing — debugging as a small science experiment, not flailing.
- Import
- A line, usually at the top of a file, that means 'this file uses code from other files.' Reading the imports tells you what a file depends on without decoding its logic.
- Iteration
- Refining in the same conversation ('warmer, less jargon') instead of restarting. The conversation itself is the tool.
- Known-good state
- A saved version of the project that you know works — your guaranteed way back. You create it BEFORE making an edit (a vibe tool's version history, or a Git commit), so a broken edit is always one undo away from fixed.
- Large language model (LLM)
- The technology behind tools like ChatGPT and Claude. A system trained on a huge amount of text that works by predicting the most likely next word.
- MCP (Model Context Protocol)
- An open standard — a shared, published agreement, not a product — introduced by Anthropic in late 2024 for connecting AI apps to tools and data in one uniform way. Often called 'a USB-C port for AI': build a connection once, plug in anywhere.
- MCP server
- A small program that exposes a tool or data source (a calendar, a database, a file system) in the MCP-standard way, so any MCP-compatible AI app can use it without a custom connector.
- Mega-prompt
- One enormous prompt that asks the AI to do many things at once. Tends to disappoint because the model's attention is spread thin and any failure is hidden in one opaque answer with no way to tell which part broke.
- Memory
- A separate feature (e.g. ChatGPT memory, Claude Projects, Gemini personalization) that saves small notes about you and re-inserts them into the context window of future chats. The model still isn't recalling anything — the tool is re-pasting saved context for it.
- Mode
- An extra ability you switch on inside a chat assistant so it can do more than reply with text — web search (current info with sources), file upload (read your document), image/vision (see a picture), image generation, or voice. The mode you pick changes how good and trustworthy the answer is.
- Next-word prediction
- The core mechanism of an LLM: given some text, it produces the most plausible continuation, one piece at a time. Reasoning-like behaviour emerges from doing this extremely well.
- Open standard
- A published, shared specification anyone is free to implement, governed by a community rather than owned by one company — like the USB-C plug shape. MCP is one; it is not an app you buy.
- Orchestrator
- The main agent that doesn't do the detail work itself — it breaks a job into pieces, hands each to a subagent, and assembles the returned results. The 'lead' in the orchestrator-worker pattern.
- Package manager
- A tool that automatically fetches all the dependencies a project needs, at the right versions, and puts them where the project expects. You don't master one — you recognise it: `npm` for JavaScript, `pip` for Python.
- Parallelism
- Doing several things at the same time instead of one after another. Running ten subagents simultaneously finishes far sooner than running ten tasks in a row.
- Path
- The address of a file or folder, written as a chain of folder names, like `/Users/you/projects/site`. It tells the computer exactly where something lives.
- Persistence
- The property of data staying saved even after the program ends, the page reloads, or the device is switched off. The opposite of temporary page memory, which is wiped like a whiteboard the moment you leave.
- Pipeline
- Another word for a chain of steps that processes something stage by stage — e.g. research → draft → critic → ship. Each stage takes the previous stage's output and produces the next.
- Project
- A saved AI workspace that bundles reusable context — uploaded files, standing instructions, and its own chat history — and applies it to every chat inside it, so you set things up once instead of re-pasting every time. ChatGPT Projects, Claude Projects, and Gemini Gems are the same idea.
- Project instructions
- Standing directions saved on a project (also called custom instructions) that apply to every chat in it — for example 'act as my brand's copywriter, British English, no hype words'. Like a role and rules you set once instead of repeating each conversation.
- Project knowledge
- The files you upload into a project once — a style guide, reference docs, examples — that every chat in that project can see automatically, without re-uploading. It's persistent context attached to the workspace, not to a single chat.
- Prompt
- What you send the AI. Not a search query — think of it as briefing a collaborator. Its quality sets the ceiling on the output.
- Prompt chaining
- Breaking one big job into several focused prompts run in order, each doing one thing well, with each result passed forward as the next step's input. Beats one giant 'mega-prompt' on quality and on finding what broke.
- Query
- A precise written request sent to a database — either a question ('give me this user's unfinished to-dos') or a change ('add this row', 'mark this row done'). With AI tools, the AI writes the query for you; your job is to understand what it's doing.
- Relative path
- A path written starting from wherever you currently are (your `pwd`), e.g. just `index.html` or `../site`. Like saying 'two doors down' — only meaningful relative to where you're standing. `.` means the current folder, `..` the parent, `~` your home folder.
- Repository (repo)
- An ordinary project folder with change-tracking switched on. Concretely, a folder that contains a hidden `.git` folder where git keeps a history of every change. Not magical, not separate from a folder — it IS a folder, plus that diary.
- Reproducible case
- The smallest, exact set of steps that reliably triggers a problem ('click Save with the form empty → page goes blank, every time'). A tight, repeatable description gives the AI a target small enough to actually hit.
- Request/response cycle
- The round trip behind every click: the frontend sends a request (a message over the internet) to the backend, the backend works and often reads or writes the database, then sends a response back that the frontend uses to update the screen.
- Revert
- Rolling back to an earlier saved version that worked, instead of patching your way forward. Most vibe-coding tools keep a version history for exactly this. Going back to a known-good state usually beats digging deeper.
- Role prompting
- Telling the AI who to be ('you are a patient tax accountant…'). It steers the answer toward the relevant region of what the model learned.
- Rollback
- Restoring the previous working version of your live project with one click when a new deploy is broken. The bad deploy sat alongside the good one rather than destroying it — this is why deploying is reversible, not a scary one-way event.
- Row
- One complete entry in a table, read across all its columns — for example, a single individual to-do. Adding an item adds a row; deleting it removes that row.
- Saved prompt
- A prompt you have used before that reliably worked, kept and named so you reuse and tweak it instead of rewriting it from scratch each time. The reusable-brief building block of a toolkit.
- Schema
- The blueprint of a database: which tables exist and what columns each one has. It defines the shape data must fit into.
- Secret/API key
- A sensitive credential — an AI model API key, a database password, a payment token — that proves it's you and can cost real money if abused. It must never appear in your code or repo; only its name appears, and the value lives in an environment variable in the platform's settings. If one leaks, revoke it immediately.
- Sensitive data
- Information that shouldn't be handed to a third-party AI tool — passwords, financial account numbers, other people's private details, confidential material you're not cleared to share. Especially risky inside a persistent project, which retains it across many chats rather than just one.
- Server
- A computer, owned by you or a hosting provider rather than the user, that runs the backend and stays on so it can answer requests from anyone, anytime. Not a special kind of machine — just one given that job.
- Shell
- The program inside the terminal window that reads what you typed and makes the computer do it. If the terminal is the window, the shell is the assistant standing at it, listening. Common ones are called Bash or Zsh; a beginner does not need to care which.
- Signal vs noise
- Telling the few things that genuinely matter (signal) apart from the endless stream that doesn't (noise). A curated weekly summary from someone you trust is signal; an infinite feed of hot takes and announcements is noise. Adding more sources usually adds noise, not understanding.
- Skill atrophy
- When handing a task to AI also hands away the practice that keeps you sharp at it, so the underlying skill quietly degrades. The risk: you lose the judgment you'd need precisely when you have to tell whether the AI is wrong.
- Spot-check
- Sampling a few claims from an output and sanity-checking them rather than auditing every line. Appropriate for low-stakes, reversible work; not enough on its own for consequential or irreversible results.
- Stack trace
- The longer block of text under an error showing the trail of where the program was when it failed. Paste the whole thing to your AI when reporting a bug — the most useful part is often near the top.
- Subagent
- A fresh, separate agent spun up by a main agent to do one focused sub-task and report back. It has its own clean working memory and returns only its conclusion, not the mess it made getting there.
- sudo
- A word you put before a command meaning 'run this with full administrator power over the whole machine, safety rails off' — the digital master key to the building. Rarely needed for a basic setup; never paste a `sudo` command you don't understand.
- Syntax
- The punctuation and grammar rules of a programming language — the brackets, semicolons, and keywords. Recognising syntax (this is a function, this is an import) is enough to orient; you don't need to be able to produce correct syntax yourself.
- System prompt
- Standing instructions a tool carries into every conversation automatically — your role, tone, and hard rules — so you set your context once instead of re-typing it each chat. In ChatGPT this slot is called 'custom instructions'.
- Tab-completion
- Pressing the Tab key to have the terminal finish a half-typed file or folder name for you. If it won't complete, that name doesn't exist there — a built-in typo catcher.
- Table
- How a database organises one kind of information: a grid, like a single sheet in a spreadsheet. An app's data is usually just a few of these grids (one for users, one for to-dos, and so on).
- Template
- A reusable skeleton for a deliverable you produce again and again — fixed structure, your acceptance criteria baked in, blanks for the specifics — so you only supply the content, not the shape, each time.
- Terminal
- A window where you tell your computer to do things by typing text instead of clicking. It is the same computer, the same files, and the same machine you already use — just reached through a different door. The plain-text look is a leftover from the 1970s, not a sign of danger.
- The stack
- The set of layers that together make an app work — typically the frontend, the backend, and the database. Naming the layers turns an unfamiliar codebase into a map.
- Time-boxing
- Giving a task a fixed, small amount of time decided in advance (e.g. 30 minutes) instead of an open-ended one. Used here to try a new tool cheaply on a low-stakes task and judge it by one question: did it make a real task of mine faster or better?
- Token
- The small chunk of text an AI counts in, very roughly three-quarters of a word. The context window's size is measured in tokens, so everything you paste 'uses up' space on the desk.
- Tool
- Something an AI can call to act beyond producing text — running code, reading or editing a file, searching the web, querying a database. The result comes back to the AI and informs its next move.
- Tool call
- The structured request a model emits when it wants a tool used — e.g. 'call search_web with this query'. The model only requests it; the surrounding program actually runs it and feeds the result back.
- Tool use
- Letting an AI actually do something in the world — run a command, edit a file, search the web — and then see the result. Tool use is the single capability that turns a text-only chatbot into an agent.
- Training cutoff
- The date an AI's knowledge stops. Plain chat has no live internet, clock, or calculator — so 'recent' or 'today' questions are unreliable without tools.
- Training data
- The body of text an AI learned from, up to a fixed 'cutoff' date. Out of the box it knows nothing after that date unless a tool lets it search.
- Tree
- The shape of a filesystem: one top point (the root) with folders inside folders inside folders, and files as the end points. Every file and folder sits somewhere on this single branching structure.
- Validation gate
- A checkpoint inserted between two steps that inspects a step's output against a fixed rule and refuses to pass it on if it fails — so an error is caught where it started instead of compounding through later steps.
- Verify
- Independently checking an AI's factual claims (and that its sources exist) before relying on them — a routine habit, not an afterthought.
- Version control
- Keeping a complete history of every change to a project, so you can see what changed, when, and roll back. It's the safety net that lets you (or an AI) experiment without losing earlier work.
- Vibe coding
- Describing what you want in plain English and letting an AI build the working software, steering by the results rather than by reading code. Coined by Andrej Karpathy in February 2025.
- Vibe-coding tool
- An app that turns a plain-English description into a real, runnable website or program — for example v0, Lovable, Bolt, Replit, or Claude. A different category from chat assistants, which produce text and documents rather than working software.
- Web search
- A mode that lets a chat assistant look up current information on the internet and cite sources, instead of relying only on what it learned up to its training cutoff date.
- Web-search mode
- A chatbot's ability to look things up on the live internet during a conversation, instead of answering only from what it learned in training. Helps with recent topics — but its results are still web results you should check at the actual page.
- Workflow
- A sequence of AI steps you design in advance, where the output of one step feeds into the next along a predefined path. Predictable and easy to trust because you chose every step and checkpoint.
taught in: Files, folders, and what a repo is · L2see also: Path, Relative path
taught in: Directing AI to produce real artifacts · L1see also: Artifact, Iteration
taught in: Judgment: when not to use AI · L5see also: Human-in-the-loop, Automation bias
taught in: What an AI agent actually is · L4see also: Agent loop, Tool, Tool use, Large language model (LLM)
taught in: What an AI agent actually is · L4see also: Agent, Tool use, Iteration
taught in: Building your personal AI toolkit · L5see also: Saved prompt, System prompt, Project, Template
taught in: Your first real commands · L2see also: Command, Flag, Path
taught in: Vibe-coding tools: describe it, get an app · L1see also: Vibe coding, Deploy
taught in: The everyday AI toolbelt · L1see also: Iteration, Chat assistant
taught in: Directing AI to produce real artifacts · L1see also: Artifact
taught in: Judgment: when not to use AI · L5see also: Accountability gap, Confidence ≠ correctness, Verify
taught in: What an AI agent actually is · L4see also: Agent, Guardrail
taught in: Vibe-coding tools: describe it, get an app · L1see also: Frontend (UI)
taught in: The wider stack: frontend, backend, deploy · L3see also: Frontend (UI), Request/response cycle
taught in: Debugging with AI as a pair · L3see also: Debugging, Error message
taught in: Judgment: when not to use AI · L5see also: Skill atrophy, Human-in-the-loop
taught in: The everyday AI toolbelt · L1see also: Large language model (LLM), Mode, Vibe coding
taught in: Databases, conceptually · L3see also: Table, Row
taught in: What the terminal actually is · L2see also: Terminal, Command line, Prompt
taught in: What the terminal actually is · L2see also: Terminal, Command
taught in: Reading code you didn't write · L2see also: Syntax
taught in: What AI can't (and shouldn't) do · L0see also: Hallucination, Verify
taught in: Reading code you didn't write · L2see also: Entry point
taught in: Iterating: getting unstuck with AI · L1see also: Reproducible case
taught in: Talking to AI: prompting that works · L0see also: Prompt
taught in: Subagents and delegation · L4see also: Context, Subagent
taught in: Context, memory, and why AI forgets · L0see also: Context window
taught in: Context, memory, and why AI forgets · L0see also: Context, Token, Context rot
taught in: Subagents and delegation · L4see also: Delegation
taught in: Your first real commands · L2see also: Command line
taught in: The wider stack: frontend, backend, deploy · L3see also: Backend, The stack
taught in: Debugging with AI as a pair · L3see also: Bug, Hypothesis, Reproducible case
taught in: Subagents and delegation · L4see also: Orchestrator, Subagent
taught in: Files, folders, and what a repo is · L2see also: Repository (repo)
taught in: Environments, installs, and not breaking things · L2see also: Package manager, Environment
taught in: Vibe-coding tools: describe it, get an app · L1see also: Vibe coding
taught in: Chaining AI into workflows · L4see also: Validation gate, Deterministic
taught in: Editing the code AI writes · L3see also: Revert, Verify
taught in: Your first real commands · L2see also: Path, Command
taught in: Shipping something live · L3see also: Deploy, Hosting
taught in: Iterating: getting unstuck with AI · L1see also: Iteration, Revert, Reproducible case
taught in: Reading code you didn't write · L2see also: Function, Config
taught in: Environments, installs, and not breaking things · L2see also: Dependency, Package manager
taught in: Shipping something live · L3see also: Secret/API key, Repository (repo), Hosting
taught in: Debugging with AI as a pair · L3see also: Stack trace, Console, Bug
taught in: Evaluating and trusting agent output · L4see also: Ground truth, Acceptance criteria
taught in: Your first real commands · L2see also: Command, Argument
taught in: Staying current without drowning · L5see also: Signal vs noise, Time-boxing
taught in: Vibe-coding tools: describe it, get an app · L1see also: Backend
taught in: Reading code you didn't write · L2see also: Import, Syntax
taught in: Files, folders, and what a repo is · L2see also: Version control, Repository (repo)
taught in: Environments, installs, and not breaking things · L2see also: Package manager, sudo, Directory
taught in: Evaluating and trusting agent output · L4see also: Evaluation (eval), Verify
taught in: What an AI agent actually is · L4see also: Autonomy, Agent
taught in: What an AI model actually is · L0see also: Next-word prediction
taught in: Tool use and MCP: giving AI hands · L4see also: Tool call, Agent, MCP server
taught in: Wiring AI into your real work · L5see also: Workflow
taught in: Shipping something live · L3see also: Server, Deploy, Domain/URL
taught in: Evaluating and trusting agent output · L4see also: Validation gate, Agent
taught in: Staying current without drowning · L5see also: Verify, Confidence ≠ correctness, Signal vs noise
taught in: Debugging with AI as a pair · L3see also: Debugging
taught in: Reading code you didn't write · L2see also: Function
taught in: Talking to AI: prompting that works · L0see also: Prompt
taught in: Editing the code AI writes · L3see also: Revert, Git, Iteration
taught in: What an AI model actually is · L0see also: Next-word prediction, Training data
taught in: Tool use and MCP: giving AI hands · L4see also: MCP server, Tool use, Open standard
taught in: Tool use and MCP: giving AI hands · L4see also: MCP (Model Context Protocol), Tool use, Harness
taught in: Chaining AI into workflows · L4see also: Prompt chaining, Prompt
taught in: Context, memory, and why AI forgets · L0see also: Context window, Context
taught in: The everyday AI toolbelt · L1see also: Chat assistant, Web search, Context
taught in: What an AI model actually is · L0see also: Large language model (LLM)
taught in: Tool use and MCP: giving AI hands · L4see also: MCP (Model Context Protocol)
taught in: Subagents and delegation · L4see also: Subagent, Delegation
taught in: Environments, installs, and not breaking things · L2see also: Dependency, Global vs local install
taught in: Subagents and delegation · L4see also: Subagent
taught in: Your first real commands · L2see also: Directory
taught in: Databases, conceptually · L3see also: Database
taught in: Chaining AI into workflows · L4see also: Workflow, Prompt chaining
taught in: Files, projects, and giving AI context · L1see also: Project knowledge, Project instructions, Context
taught in: Files, projects, and giving AI context · L1see also: Project, Project knowledge
taught in: Files, projects, and giving AI context · L1see also: Project, Context
taught in: Chaining AI into workflows · L4see also: Workflow, Prompt, Pipeline
taught in: Databases, conceptually · L3see also: Database, Table
taught in: Files, folders, and what a repo is · L2see also: Path, Absolute path
taught in: Files, folders, and what a repo is · L2see also: Version control, Git, Directory
taught in: Iterating: getting unstuck with AI · L1see also: Doom loop
taught in: The wider stack: frontend, backend, deploy · L3see also: Frontend (UI), Backend, Browser
taught in: Iterating: getting unstuck with AI · L1see also: Doom loop, Vibe-coding tool
taught in: Talking to AI: prompting that works · L0see also: Prompt
taught in: Shipping something live · L3see also: Deploy, Hosting
taught in: Databases, conceptually · L3see also: Table, Column
taught in: Building your personal AI toolkit · L5see also: Prompt, Template, AI toolkit
taught in: Databases, conceptually · L3see also: Table, Column, Database
taught in: Shipping something live · L3see also: Environment variable, Repository (repo)
taught in: Files, projects, and giving AI context · L1see also: Project knowledge
taught in: The wider stack: frontend, backend, deploy · L3see also: Backend, Deploy
taught in: What the terminal actually is · L2see also: Terminal, Command
taught in: Staying current without drowning · L5see also: FOMO learning, Hype
taught in: Judgment: when not to use AI · L5see also: Automation bias
taught in: Evaluating and trusting agent output · L4see also: Ground truth, Acceptance criteria
taught in: Debugging with AI as a pair · L3see also: Error message, Console
taught in: Subagents and delegation · L4see also: Orchestrator, Delegation, Context isolation
taught in: Environments, installs, and not breaking things · L2see also: Command, Global vs local install
taught in: Reading code you didn't write · L2see also: Function, Comment
taught in: Building your personal AI toolkit · L5see also: Prompt, Context, AI toolkit
taught in: Your first real commands · L2see also: Command line
taught in: Databases, conceptually · L3see also: Row, Column, Schema, Database
taught in: Building your personal AI toolkit · L5see also: Saved prompt, AI toolkit
taught in: What the terminal actually is · L2see also: Command line, Shell, Command, Prompt
taught in: The wider stack: frontend, backend, deploy · L3see also: Frontend (UI), Backend, Database
taught in: Staying current without drowning · L5see also: FOMO learning
taught in: Context, memory, and why AI forgets · L0see also: Context window
taught in: What an AI agent actually is · L4see also: Tool use, Agent
taught in: Tool use and MCP: giving AI hands · L4see also: Tool use, Harness
taught in: What an AI agent actually is · L4see also: Tool, Agent, Agent loop
taught in: Files, folders, and what a repo is · L2see also: Directory, Path
taught in: Chaining AI into workflows · L4see also: Deterministic vs probabilistic, Verify, Workflow
taught in: What AI can't (and shouldn't) do · L0see also: Confidence ≠ correctness
taught in: Files, folders, and what a repo is · L2see also: Git, Repository (repo)
taught in: The everyday AI toolbelt · L1see also: Vibe-coding tool, Chat assistant
taught in: The everyday AI toolbelt · L1see also: Vibe coding, Chat assistant
taught in: The everyday AI toolbelt · L1see also: Mode, Training data
taught in: Trust but verify: hallucinations and checking output · L0see also: Training cutoff
taught in: Chaining AI into workflows · L4see also: Prompt chaining, Pipeline, Agent, Validation gate