Start here / 7 groups / 92 terms / read in about 40 minutes
Before the modules, get the words straight. This page explains, in plain language, the terms you will hear every day as an FDE: what a model actually is, how Claude the app differs from the Anthropic API, what a harness and a context are, open versus closed models, networks and VPCs, and why data privacy and security matter so much. Skim it once now, and come back whenever a word in a lesson is unclear.
16 terms
Most confusion starts here. A model is not a database and not a search engine. It is a trained pattern machine that writes the most likely next piece of text. Once that clicks, a lot of its behavior, good and bad, makes sense.
How a model comes to exist, and how you use it
Software that does tasks we used to think needed human judgment: reading, writing, recognizing images, making predictions.
Why it matters: It is an umbrella word. When a client says AI, ask what they actually mean: a chatbot, a prediction, document reading or automation.
Building software by letting it learn patterns from examples, instead of a person writing every rule.
Think of it like: Showing a new clerk a thousand past invoices instead of handing them a rulebook for every supplier.
Why it matters: Machine learning depends on data. The quality of the examples decides the quality of the result.
The product of training: a very large set of numbers that turns an input into an output. It does not look answers up in a stored table; it computes a likely answer from patterns it learned.
Think of it like: A well-read person's trained intuition, not a filing cabinet.
Why it matters: Because a model computes rather than retrieves, it can sound fluent and still be wrong. When exact facts matter, give it the source text.
Not the same as: A database stores records and returns exactly what was saved. A model stores patterns and generates new text.
The numbers inside a model that training adjusts. Model size is often quoted in billions of parameters, such as a 70B model.
Why it matters: Bigger usually means more capable but slower and more expensive to run. It matters most when you host a model yourself.
The large, one-time training run where the model reads a vast amount of text and learns to predict the next piece of it.
Why it matters: This is done by AI labs at enormous cost. On a client project you use a trained model; you do not train one.
Extra training after pre-training. Post-training turns a raw text predictor into a helpful assistant that follows instructions. Fine-tuning adapts a model to a narrow task with your own examples.
Why it matters: Fine-tuning is rarely the first step. Good prompts and retrieval are cheaper, faster and easier to change.
Using a trained model to produce an output. Every request you send is one inference.
Why it matters: Inference is what you pay for, per use, and what decides how fast your solution responds.
A model trained to predict the next piece of text from the text before it.
Think of it like: The word suggestions on your phone keyboard, scaled up enormously.
Why it matters: Answering questions, summarizing, translating and writing code all come from this one skill done extremely well.
A language model with billions of parameters, trained on a very large amount of text and code. Examples: Claude (Anthropic), GPT (OpenAI), Gemini (Google), Llama (Meta), and models from Mistral, DeepSeek and Qwen.
Why it matters: LLMs are general purpose. The same model can sort tickets, draft emails, read contracts and write SQL.
The unit an LLM reads and writes: a word, part of a word or a punctuation mark. A common rule of thumb for English is that 100 tokens is about 75 words.
Why it matters: Prices, limits and speed are all measured in tokens, so you will estimate them in every business case.
How an LLM writes: it predicts one token, adds it to the text, then predicts the next, until it decides to stop.
Why it matters: There is no finished answer waiting inside. Clear instructions at the start shape every step that follows.
A setting that controls how much randomness goes into choosing each next token. Lower is more repeatable; higher is more varied.
Why it matters: The same prompt can give different answers. For extraction and classification keep randomness low, and still test the output.
When a model states something false with confidence, such as an invented citation or a policy clause that does not exist.
Why it matters: It follows directly from predicting likely text without checking facts. Ground answers in sources and measure them on real cases.
Models that work through intermediate steps before giving the final answer. Claude, OpenAI and Gemini all offer this mode.
Why it matters: Better on multi-step problems, but it uses more tokens and takes longer. Turn it on where it earns its cost.
A model that accepts more than text: images, PDFs and sometimes audio.
Why it matters: Many client documents are scans, photos and screenshots. Multimodal models can read them directly.
A list of numbers that represents the meaning of a piece of text, so texts with similar meaning get similar numbers. Made by an embedding model.
Why it matters: Embeddings let you search documents by meaning, not just keywords. That is the search step inside most RAG systems.
15 terms
One company can offer the same model in several ways: a chat app for people, an API for programs, and ready-made tools such as coding agents. They share a model but differ in price, data terms and what you can build. When a client says we use Claude or we use ChatGPT, your first question is: which one?
Same models, three different products
Where each piece sits
A company that trains and serves models. Anthropic makes Claude. OpenAI makes GPT and Codex. Google makes Gemini. Meta makes Llama. Mistral, DeepSeek and Alibaba (Qwen) also publish models.
Why it matters: Each has its own prices, terms, regions and strengths. Clients often already have a contract with one, which can decide your choice.
Providers release models in families and versions. Claude, for example, comes as Opus, Sonnet and Haiku, from most capable to fastest and cheapest. Old versions are retired over time.
Why it matters: Pin the exact model name in your code so results do not change underneath you, and plan for upgrades.
The name of Anthropic's family of models, and also of the Claude app (web, desktop and mobile) where people chat with those models.
Why it matters: Because one word means two things, always clarify: the app people use, or the model called from a system through the API.
A finished product for people: you type, it answers. Examples: the Claude app, ChatGPT, Gemini, Microsoft Copilot. Sold as individual, team and enterprise plans.
Why it matters: Excellent for research, drafting and learning. It is not how you build an automated process that runs without a person typing.
Application Programming Interface: an agreed way for one program to ask another for data or actions over the network.
Think of it like: A restaurant's order window. You hand in an order in the agreed format and get your food back; you never go into the kitchen.
Why it matters: Everything you build talks to a model, and to the client's systems, through APIs.
The developer service for calling Claude models from your own code, paid per token, using an API key from the Claude Console. Claude models are also offered through Amazon Bedrock, Google Cloud Vertex AI and Microsoft Foundry.
Why it matters: This is how a POC uses Claude inside a client process: your code sends the document and instructions, and gets structured results back.
Not the same as: The Claude app is a product for people chatting. The API is a service for programs. Same models, but different billing, different controls and often different data terms.
Software Development Kit: a library that makes an API easy to call from a language such as Python or TypeScript. Anthropic, OpenAI and Google all publish official SDKs.
Why it matters: Use the official SDK. It handles details such as retries and request formats so you write less code.
A secret string that identifies your account when you call an API.
Why it matters: Anyone holding it can spend your money and reach whatever it can reach. Never put keys in code, chats, documents or screenshots.
Large clouds resell models inside their own accounts: Amazon Bedrock, Google Vertex AI and Microsoft Azure AI Foundry.
Why it matters: Enterprises often must use their existing cloud for billing, security reviews, private networking and data residency.
The prompt is everything you send: instructions, data, examples and the question. The system prompt is the builder's standing instructions for the whole conversation: role, rules and output format.
Why it matters: Most quality gains on a POC come from clearer prompts, not from a different model.
The software around a model that turns it into a working tool. It builds the prompt, keeps the conversation, offers tools, runs them when the model asks, and decides when to stop.
Think of it like: The model is the engine. The harness is the rest of the car: steering, brakes, dashboard.
Why it matters: Two products using the same model can behave very differently because of their harness. Claude Code, Codex, Cursor and your own agent code are all harnesses.
A way for the model to ask the harness to run something: search, read a file, call an API. The model only asks; your code decides whether to run it and sends back the result.
Why it matters: This is how an LLM touches real systems, so it is where permissions and approvals matter most.
A model working in a loop: plan, use a tool, look at the result, continue, until the task is done.
Why it matters: Powerful but harder to predict and test. Use a simple fixed workflow when that is enough.
An open standard for connecting AI applications to tools and data. A system is exposed once as an MCP server, and any app that supports MCP can use it.
Think of it like: A USB-C port for AI tools: one plug shape that many devices understand.
Why it matters: Lets a client connect their systems once and reuse them across AI tools, instead of building a custom integration for each.
A harness for software work. It reads your repository, edits files, runs tests and commands. Examples: Claude Code (Anthropic), Codex (OpenAI), Gemini CLI (Google), Cursor and GitHub Copilot.
Why it matters: The fastest way to build a POC, as long as you review every change and understand what it ran.
10 terms
A model knows only two things: what it learned in training, and what is in front of it right now. That second part is the context. Most quality problems in a POC are context problems: the right fact was missing, buried or drowned in noise.
What goes into one request
Everything the model can see for one request: the system prompt, conversation history, documents, tool results and your latest message.
Think of it like: The papers on the desk of a very fast reader who remembers nothing from yesterday.
Why it matters: If a fact is not in its training and not in the context, the model can only guess. Your job is to put the right facts on the desk.
The maximum amount of text, in tokens, a model can take in one request, including its answer. Current large models handle hundreds of thousands of tokens, some up to a million.
Why it matters: Large, but not free: every token costs money and time, and quality can drop when the key fact is buried in a huge pile.
The model itself does not remember earlier requests. Chat apps seem to remember because the harness resends the conversation each time.
Why it matters: In your own build, you must send the history, or a summary of it, yourself.
A harness feature that saves notes between sessions, such as preferences or past decisions, and adds them back into the context later.
Why it matters: It is the harness storing text, not the model learning. Know what is saved and where, because it may hold client data.
The date after which the model saw no training data.
Why it matters: It does not know about later events, prices or policy changes unless you put them in the context.
First search your documents for the passages that matter, then put them into the context with the question, and ask the model to answer from them.
Why it matters: The standard way to answer from client documents with citations, without retraining anything.
Deciding what goes into the context, in what order and how much, so the model has what it needs and nothing that distracts it.
Why it matters: More is not always better. Irrelevant text raises cost and can lower quality.
Reusing the already-processed start of a prompt, such as a long policy document, across many requests so the repeated part is cheaper and faster.
Why it matters: A simple cost and speed win when every request starts with the same large instructions or documents.
The cap you set on how long an answer can be.
Why it matters: Too low and answers get cut off mid-sentence; too high and a runaway answer costs more.
The maximum requests or tokens your account may use per minute.
Why it matters: Batch jobs over thousands of client documents hit these limits. Plan for retries and pacing.
8 terms
Some models you can download and run on your own machines. Others you can only use through the provider's service. Neither is always better; the choice depends on capability, data rules, cost and who will run it.
Closed versus open-weight, side by side
A model whose weights are not published. You use it only through the provider's app or API, or a cloud partner. Examples: Claude, most GPT models, Gemini.
Why it matters: Least effort to start and usually the most capable, but data goes to the provider under their terms.
A model whose trained weights are published, so anyone can download and run it under its license. Examples: Llama (Meta), Gemma (Google), gpt-oss (OpenAI), and models from Mistral, DeepSeek and Qwen.
Why it matters: Can run entirely inside a client's network, but then you own hosting, scaling, updates and safety testing.
Strictly, a model is open source only when the weights, the code and enough detail about the training data to rebuild it are available under a license that allows any use. Many models called open are open-weight only.
Why it matters: Licenses differ and some restrict commercial use or large companies. Read the license; the client's legal team will ask.
The most capable models available at a given time, usually from the large labs and usually closed.
Why it matters: A sensible default for a POC, because it shows what is possible before you optimize for cost.
Running a model on servers you control, in your own cloud account or data center.
Why it matters: Useful when data must not leave, but it needs GPUs, engineering time and ongoing operations.
A smaller model running on a laptop or a single server, using tools such as Ollama.
Why it matters: Good for learning, offline demos and very sensitive tests. Usually less capable than frontier models.
The legal terms for using a model's weights: commercial use, user limits and acceptable use rules.
Why it matters: A model you cannot legally use in production is not an option, however good it is.
A standard test used to compare models, such as a set of exam questions or coding tasks.
Why it matters: Useful as a rough guide only. Your own evaluation on the client's real cases decides.
15 terms
Every AI solution moves data across networks: from a user's laptop, through the company network, over the internet, into a cloud and out to a model. You do not need to be a network engineer. You do need to know where the data travels and who can reach it, because that is the first thing a client's security team will ask.
The path of one request
Computers connected so they can send data to each other. Your office network, home Wi-Fi and the internet are all networks.
Why it matters: Every integration question is really a network question: can system A reach system B?
The global network of networks. Traffic crosses many organizations' equipment on its way.
Why it matters: Anything sent over it unencrypted can be read along the path.
The numeric address of a device on a network, such as 203.0.113.10.
Why it matters: Firewalls and allow-lists use IP addresses to decide who may connect.
The internet's phone book. It turns names like api.example.com into IP addresses.
Why it matters: When something cannot connect, a DNS problem is one of the first things to rule out.
A numbered door on a computer for one kind of service. HTTPS normally uses port 443.
Why it matters: Corporate firewalls often block every port except a few, which can stop a tool from working.
HTTP is the format browsers and APIs use for requests and responses. HTTPS is HTTP encrypted with TLS so nobody on the path can read or change it.
Why it matters: Client data must only travel over HTTPS. Plain HTTP is not acceptable.
Rules that allow or block traffic by address, port or application.
Why it matters: Your POC may need a firewall change to reach a model API or a client system. Those requests take time; ask early.
A Virtual Private Network: an encrypted tunnel from your device into a private network, so you can reach internal systems as if you were in the office.
Why it matters: You will often need the client's VPN to reach their test systems.
Renting computing, storage and services from providers such as AWS, Microsoft Azure and Google Cloud instead of owning the hardware.
Why it matters: Most client systems and most AI services now run in a cloud.
A geographic location where a cloud runs its data centers, such as Frankfurt or Virginia.
Why it matters: Data residency rules can require data to stay in a country or region, which limits which services you can use.
Your own isolated private network inside a public cloud. You decide its addresses, what can reach the internet and what cannot.
Think of it like: A locked, private office floor inside a shared tower block.
Why it matters: Client data usually lives inside a VPC. Your POC may need to run in the same VPC, or connect to it securely, to reach that data.
A slice of a VPC. Public subnets can reach the internet directly; private subnets cannot.
Why it matters: Databases sit in private subnets on purpose. That is why your laptop cannot simply connect to them.
A way to reach a cloud service, including some model services, without traffic going over the public internet.
Why it matters: Often a security requirement for enterprise AI, and a reason clients prefer models through their own cloud.
Systems running in the company's own data center instead of a cloud.
Why it matters: Older core systems often live here. Reaching them from a cloud POC needs a secure connection.
The delay between sending a request and getting the response.
Why it matters: Distance, network hops and model size all add to it. Users notice anything over a few seconds.
16 terms
Clients hand you their most sensitive material: customer records, contracts, employee files, prices. Handling it carelessly can end an engagement, break the law and hurt real people. Learn these words, because the client's security and legal teams use them in every conversation.
Why be careful
Can this data go to an AI service?
Do not send it. Use synthetic or masked data until an approved setup exists.
Send only the fields the task needs, keep a log, follow the agreed retention.
Fine to use. Still keep keys, passwords and internal names out.
Information that identifies a person directly or indirectly: name, email, phone number, ID numbers, and under many laws also location and online identifiers.
Why it matters: Most privacy laws attach duties to personal data. Spot it before it goes anywhere.
Data that needs extra protection: health, financial, biometric and children's data, among others defined by law. Commercially sensitive data such as prices, contracts and source code also counts for clients.
Why it matters: Sensitive data usually needs explicit approval, stronger controls and sometimes cannot leave the client at all.
The rules about personal data: what may be collected, for what purpose, who may see it and how long it is kept.
Why it matters: The question it answers is: are we allowed to use this data in this way?
Not the same as: Privacy is about the rules for using data. Security is about protecting data. You can be perfectly secure and still break privacy rules, for example by using data for a purpose people never agreed to.
Protecting data from unauthorized access, change or loss, through encryption, access control and monitoring.
Why it matters: The question it answers is: can anyone who should not see this data get to it?
The EU General Data Protection Regulation sets rules for personal data of people in the EU, including purpose limits, data minimization and individual rights. Many other places have similar laws, and some sectors have their own, such as HIPAA for health data in the US.
Why it matters: Ask the client which laws apply before you touch any data.
Use only the data the task actually needs, and remove or mask the rest.
Why it matters: The simplest privacy control an FDE can apply, every day, without asking anyone.
Ways to remove or replace identifiers. Anonymized data can no longer be linked to a person. Pseudonymized data replaces names with codes but can be linked back with a separate key.
Why it matters: Under GDPR, pseudonymized data is still personal data. Do not call it anonymous.
Where data is physically stored and processed.
Why it matters: Some clients require data to stay in one country or region, which rules out some services and regions.
How long data is kept, including copies in logs, backups and at the AI provider.
Why it matters: Agree retention up front and delete POC data when the engagement ends.
Whether a provider uses your inputs to improve its models. Business API and enterprise plans of the major providers generally do not by default; consumer apps may, depending on the plan and settings.
Why it matters: Terms change. Check the current terms for the exact product and plan before any client data goes in.
In transit means protected while moving, through HTTPS and TLS. At rest means protected while stored on disk.
Why it matters: Both are basic expectations in every security review.
Give each person, service and AI tool only the access it needs, and nothing more.
Why it matters: An assistant that only needs to read tickets must not be able to delete them or read payroll.
Keeping API keys, passwords and tokens in a secret store or environment variables, never in code, documents or chats.
Why it matters: Leaked keys are one of the most common and most avoidable incidents.
A record of who did what and when, including what the AI suggested and what a person approved.
Why it matters: Required in regulated work, and the first thing anyone asks for when something goes wrong.
An attack where text inside a document, email or web page contains instructions meant to make the model do something else, such as reveal data or call a tool.
Why it matters: Any content the model reads can try to steer it. Limit what tools and data it can reach, and keep a person in the loop for risky actions.
The checks a client runs before approving a vendor: a data processing agreement (DPA), a security questionnaire and certifications such as SOC 2 or ISO 27001.
Why it matters: These can take weeks. Start them as early as possible on an engagement.
12 terms
Words you will hear in every engineering conversation. If you come from a business background, these are enough to follow along on day one; module 3 goes deeper.
The parts of a typical application
The part of an application people see and click: a web page, a mobile screen.
Why it matters: Never put secrets in the frontend. Anything sent to a browser can be read by its user.
Server-side code that holds the logic, talks to databases and calls other APIs, including model APIs.
Why it matters: This is where your model calls and API keys belong.
Organized storage for records. Relational databases such as Postgres and SQL Server store data in tables you query with SQL.
Why it matters: Most client data you need sits in a database you will query or receive an export from.
A plain-text format for structured data, made of names and values, used by almost every API.
Why it matters: You will ask models to return JSON so your code can use the result reliably.
Git records every change to code. A repository is a project folder with its full history. GitHub and GitLab host repositories online.
Why it matters: Every POC lives in a repository so others can review, run and continue it.
A separate copy of a system: development for building, test for checking, production for real users.
Why it matters: Never test on production systems or production data without explicit permission.
Putting a version of software where its users can reach it.
Why it matters: A POC is not finished until someone other than you can open it.
A package of an application plus everything it needs to run, so it behaves the same on any machine.
Why it matters: The usual way to hand a client something they can run inside their own cloud.
Running code without managing servers. The platform runs it when needed and charges per use.
Why it matters: A quick, cheap way to host a small POC.
Automated pipelines that test every change (continuous integration) and release it (continuous delivery or deployment).
Why it matters: Keeps quality steady as the POC changes quickly.
A POC proves it can work on realistic data. A pilot proves it works for real users in real work. Production is the supported, monitored service.
Why it matters: Be clear which one you are building. Each needs different quality, security and support.
A set of test cases with expected results, used to measure how well an AI solution works.
Why it matters: The difference between it seems to work and it works on 54 of 60 real cases.