AI words, in plain English.

An AI model operating autonomously across multiple steps: it plans, acts, checks its own work, and loops until the job is done. Agents can be built on any capable model — Claude, GPT-4o, Gemini, and others. Examples: a coding agent that reads your repo, writes a fix, and opens a PR; a research agent that searches the web and writes a summary; a customer-support agent that reads a ticket and drafts a reply.

In practiceThe jump from 'answer my question' to 'go handle this.' Agents are where AI stops being a search engine and starts being a coworker.

Software trained on massive text to predict the most useful next word. At scale, that becomes conversation.

In practiceThis is the engine. Everything else here is a setting, a guardrail, or a feature built on top of it.

A connection point that lets two pieces of software pass data automatically, no copy and paste required.

In practiceWhen your booking form sends a lead straight to your email list with no manual step, that is an API doing the work.

The private credential that lets one tool use Claude on your behalf. Anyone holding it can spend on your account.

In practiceTreat it like a credit card number. Never paste it in a public file, a screenshot, or a chat message.

Proving a user is who they say they are before letting them in, usually a login.

In practiceEmail and password, or 'sign in with Google,' is authentication deciding whether to open the door.

A task that runs on a trigger or schedule with no human hand on the keyboard.

In practiceThe whole point. Once you understand automation, every repetitive task becomes a candidate for elimination.

The part of your app that runs on a server, out of sight: logic, data, and the rules the frontend cannot be trusted with.

In practiceCharging a card or saving a booking happens in the backend, where a user cannot tamper with it.

The step that turns your source code into the optimized files a browser or app store actually runs.

In practice'npm run build' packages everything for production. If the build fails, nothing ships.

A plain text file in your project folder that Claude reads automatically every session as its instructions.

In practiceYour persistent memory for Claude Code. Write it once, stop repeating yourself forever.

The two sides of a web app: the client is the user's browser, the server is the machine you control.

In practiceValidate on both. The client can be tampered with, so the server gets the final say.

A saved checkpoint of your code in version control, with a short note on what changed.

In practiceCommit often. Each one is a point you can safely return to when the next change breaks something.

Claude summarizing older conversation history to make room when the context window fills up.

In practiceKeeps long sessions functional. Early details get compressed, so check that nothing critical got dropped.

A reusable building block of your interface, like a button or a card, defined once and used everywhere.

In practiceBuild the button as a component once, and every page gets the same button, fixed in one place.

The maximum amount of text Claude can hold in one conversation. Go past it and the earliest parts start disappearing.

In practiceLong sessions drift. If Claude forgets an instruction from an hour ago, you have hit the window: start fresh or compact.

The organized store where your app keeps its data: users, bookings, orders, anything that has to persist.

In practiceClose the tab and reopen it, and your data is still there. That is the database remembering.

Outside code your app relies on to work, installed rather than written by you.

In practiceEvery dependency is one more thing to trust and update. Do not add new ones without a reason.

Pushing your app live so the world can reach it, moving it from your machine to a host.

In practiceDeployment is the moment your change leaves your laptop and shows up at your real URL.

The exact lines a change adds or removes, shown side by side so you can see what really changed.

In practiceRead the diff before you accept Claude's work. It is the difference between approving and hoping.

Converting text into a list of numbers that encode its meaning, so computers can compare ideas mathematically.

In practiceThe engine behind smart search. Without embeddings, search is keyword matching. With them, it is meaning matching.

A single address on your backend that does one job when something sends it a request.

In practiceYour booking form posts to an endpoint that saves the booking. One door, one purpose.

Settings and secrets stored outside your code, so keys and passwords never live in the files you share.

In practiceYour Stripe key goes in an environment variable, not pasted into a file that could end up public.

Showing Claude two or three worked examples before your real request so it matches your format and tone.

In practiceThe highest-leverage prompting technique. One good example beats a paragraph of instructions.

Retraining a model on your own data to permanently shift its default behavior.

In practiceMore powerful than prompting, and far more expensive. Worth it when you have thousands of consistent examples and prompting hits a ceiling.

The part of your app that runs in the browser and the user sees: buttons, forms, layout, everything on screen.

In practiceWhen someone taps a button on your booking page, that is the frontend doing its job.

When an AI states something false with full confidence: invented facts, fake citations, wrong numbers.

In practiceThe most dangerous beginner blind spot. Always verify factual claims. Never cite without checking.

A rule that fires automatically when a specific event happens, like a check that runs before every file edit.

In practiceThe guardrail layer. Hooks catch mistakes before they ship without you needing to remember to check.

Checking that data coming in is what you expect before you trust it or store it.

In practiceValidating that an email field actually holds an email stops junk, and some attacks, at the door.

The standard way Claude plugs into external tools like Notion, your database, or your calendar.

In practiceWhat separates Claude as chatbot from Claude as operator. MCP is the power source for autonomous work.

A specific trained version of an AI. Different models have different speeds, costs, and reasoning depth.

In practiceYou pick the model like a tool: the cheap fast one for sorting emails, the heavy one for legal review.

Settings that control how much Claude can act on its own versus how often it pauses to ask you first.

In practiceStart restrictive. Loosen as you build trust with a workflow. Never go full auto on something you have not tested.

A setting that makes Claude lay out its entire plan before taking any action. You approve, then it proceeds.

In practiceNon-negotiable for high-stakes tasks. Catches wrong assumptions before they become wrong actions.

The instruction or question you give the AI.

In practiceThe quality of your output is almost entirely decided here. Vague in, vague out.

An attack where hidden instructions inside external content (a doc, a webpage) try to hijack Claude.

In practiceWhen Claude reads untrusted content, that content can try to make it misbehave. Awareness is the first defense.

The part of a URL after the question mark that passes small bits of data, like ?id=42.

In practiceNever put private data in a query string. URLs get logged, shared, and saved in history.

Claude searches your own documents for the relevant chunk, then answers from it.

In practiceKeeps answers grounded in your material. The difference between 'I think' and 'here is the source.'

Capping how many requests something can make in a window of time, so one user or bot cannot flood you.

In practiceRate limiting is what stops a script from hitting your login a thousand times a second.

A scheduled task Claude runs automatically: weekly digest, daily summary, nightly cleanup.

In practiceThe difference between 'I have to remember to do this' and 'it is already done when I wake up.'

An isolated environment where code or an agent runs without being able to touch the rest of your system.

In practiceThe difference between a mistake that costs seconds and one that corrupts files. Know whether your tools run sandboxed.

Private credentials your app needs but no one should see: API keys, passwords, tokens.

In practiceA leaked secret is like a lost house key. Keep them in environment variables, never in your code.

Backend code that runs on demand without you managing a server, spinning up only when called.

In practiceYour contact form can run on a serverless function: no server to babysit, you pay only when it runs.

A reusable set of instructions that teaches Claude to do one task your way, defined once and used on demand.

In practiceYour intellectual property as a Claude user. Build it once, save hours every week.

A quick check that the real path works end to end, not just that the code looks right.

In practiceBefore calling a feature done, smoke-test it: actually book the appointment, do not just read the code.

A hard dollar ceiling on an API key. When hit, the key stops working rather than running up an unlimited bill.

In practiceSet this before anything else with the API. A loop bug at 3am can generate a four-figure bill without it.

The set of tools your app is built on: the language, the framework, the database, the host.

In practiceNaming your stack once in CLAUDE.md means Claude stops guessing and writes code that fits what you use.

A focused copy of Claude assigned one specific job inside a larger task, reporting back when done.

In practiceEnables parallel work. Three subagents reviewing a contract at once beat one doing it in sequence.

The standing instruction sent before your message that frames Claude's role, tone, and rules for the whole session.

In practiceYour lever for consistent behavior. A good system prompt is worth ten repeated instructions.

A dial controlling randomness: low is predictable, high is creative and varied.

In practiceLow for structured outputs like JSON and summaries. High for brainstorming. The wrong setting is a common silent failure.

The unit AI usage is billed in, roughly a word fragment of about four characters. Input and output both cost tokens.

In practiceEvery API call has a token cost. Understanding tokens stops bill surprises when you paste a 50-page doc.

The text the model learned from during training. It shapes everything the model knows, assumes, and gets wrong.

In practiceExplains why Claude has a knowledge cutoff, and why it can reflect biases baked into the internet.

A database built to store embeddings and search by meaning rather than exact keywords.

In practiceEnables RAG at scale. Thousands of notes, and Claude finds the right one instantly.