Learn These 10 AI Concepts Before It’s Too Late

AI familiarity is no longer optional for developers. As we head further into an AIdriven economy, this skill set will become core knowledge for all software developers to understand. No, you don't have to go back to school or retake your statistics class or even know how to train models. But as a software developer, you will be asked to integrate or maintain AI of some sort in your applications, whether it's chat bots, MCP servers, or large scale systems. And having a core understanding of the terminology of LLMs in AI agents will give you an advantage over those who choose to ignore the changing landscape. In this video, I'll break down for you 10 essential AI and machine learning concepts or terms that you should already have a base understanding of. If you don't know whether to choose a 7B or 24B model, don't understand why you would need a vector database rag, or think guardrails are just a slang term, you need to watch this. you'll walk away with more tools in your belt that will give you a major advantage going forward over others. Let's jump in. This video is brought to you by Brilliant. More about them later. Number one, we have AI model parameters. When you see models described as 2B, 7B, or 40B parameters, what does this actually mean? Well, parameters are the weights inside of a neural network. So, a neural network starts with these random adjustable numbers called parameters or weights as you may have heard it. And during training, the model is fed a lot of data like images or text. It makes a prediction, checks how far off it is, and then adjusts its weights slightly to improve next time or reduce that error. This is called fine-tuning. More parameters generally mean a more capable model able to handle complex reasoning and generate better responses. But there's a trade-off. Bigger models demand more GPU memory, more compute, and usually respond slower. So when you see these parameter numbers, think of it as a balance between power and efficiency. A 7B model might run on a consumer GPU, while a 40B model could require enterprise level hardware. So in short, parameters reveal the true size of the model. And they help you judge if it's powerful enough for your goals while still fitting your hardware. I actually have a more in-depth blog post on this, including recommendations, choosing the right model, and all of that. I'll put a link to it below. Number two is quantization. So AI models are made up of billions of little numbers called weights. As we just discussed, each weight is stored with maximum detail or at full precision like a highresolution photo. Sharp but very large. Quantization is like compressing those images. Instead of storing every number in full detail, we store them in a smaller format. The picture looks almost the same, but the file size drops dramatically. Now, why does this matter? Well, it makes models smaller and faster. So, you can run big ones on consumer GPUs. So, with 4-bit quantization, a 30 billion parameter model can drop from 80 GB of VRAM to roughly 20 GB. And the trade-off is a little loss in accuracy or nuance, like a compressed JPEG versus the original. Here are some quick guidelines for developers. If you're building a chatbot, coding helper, or internal app, a quantized model is usually more than enough to fit your needs. But if you need the absolute best precision, say for research or some sort of missionritical task, you'll want full precision. So quantization makes powerful models accessible without enterprise hardware. And for most apps, the trade-off is worth it. Again, I have a blog post in more detail on this as well, including where to find these quantized model files. Link is below to that. Number three is embeddings in vector databases. So embeddings turn different kinds of data into lists of numbers that capture meaning. Think of it this way. Every word, sentence, or image, it gets a set of coordinates, a list of numbers. And similar ideas, they land close together, like I like dogs and I enjoy puppies. But unrelated ones like I like dogs and my car broke down, they end up far apart. And this is where vector databases come in. They store all of these embeddings or vectors and let you quickly find the closest matches. So when do you actually need a vector database? Well, if it's a small project with only a few hundred or maybe even a few thousand embeddings, you can keep them in a normal database or even just in memory. However, you'll have to use some library like NumPy to calculate the distances. But once you're dealing with tens of thousands or millions of embeddings, a vector database like Pine Cone, Weev8, or PG Vector becomes essential. They'll take care of fast similarity search, scaling, and indexing for you. And as a developer, you don't need to know the math behind how embeddings are stored. What matters is this. Embeddings let AI compare by meaning or by semantics as you may have heard it. And vector databases make that comparison fast enough to power things like semantic search, chat box with context, and recommendations. Now, before we continue on with our AI and machine learning terms, you can actually get a bigger picture of how AI works overall in a fun interactive way with the sponsor of today's video, Brilliant. Brilliant is a learning app that has thousands of visual interactive lessons in math, science, programming, data analysis, AI, and ultimately serves to sharpen your thinking. Each lesson is filled with hands-on problem solving that lets you play around with concepts, which is actually a method proven to be six times more effective than watching lecture videos or trying to memorize stuff. Perhaps you want to dive deeper into large language models, big data, or just learn the basics of Python in their programming and computer science learning path. There's a number of learning paths and personally and professionally, one of the most important things you can do is aim to learn a little bit each day. Today I started a new course titled Introduction to Neural Networks, covering topics like how artificial neurons perform basic tasks like classification and estimating probability. And I'll probably shoot for 10 to 15 minutes a day as I work through these levels. And I can do that because I've downloaded Brilliant's mobile app, making it easy to learn anywhere at home or on the go. So today to begin learning for free on Brilliant, go to brilliant.org/travismedia, scan the QR code on screen or click the link down in the description. Brilliant has also given our viewers 20% off an annual premium subscription which gives you unlimited daily access to everything on Brilliant. Now let's get back to the video. All right, number four, we have RAG or retrieval augmented generation. So large language models, they don't actually know your private data. They only know what they were trained on. Well, retrieval augmented generation or rag is how we fix that. And here's how it works. Say you ask a question. The app that you just built around the model, not the model. Remember, it only knows what it was trained on. But the app that you built around the model, it goes out and it searches an external knowledge source like a vector database full of documents or a PDF, whatever. It pulls out the most relevant chunks and those chunks get added to the model's prompt. So, the answer is based on your data in addition to the model's training. Examples can include chat bots with company docs, so rag is the go-to method for grounding answers in your knowledge base. It can include big PDFs, so instead of the model making things up, your app splits the document into chunks, stores the embeddings, and then feeds back the right parts when a user asks something. It includes searches with explanations, so the system retrieves relevant passages, and the model turns them into clear natural language answers, not just a list of search hits. And it also helps with hallucination control. So rag cuts down on the model making things up by actually giving it real context first. So in short, rag is the common pattern behind most AI apps that need to work with your data. Number five, we have inference. So when you hear the word inference in AI, it just means running a train model to get results. That's all it means. Training is the expensive part which is building the model. But inference is the practical part. It's actually calling it to generate text or to classify an image or to answer a question. So yes, inference it's just running the model to get an answer. The tricky part isn't what inference is, but how to make it fast enough and cheap enough to use in real apps. So when you hear someone like Larry Ellison, the co-founder of Oracle, say people are running out of inference capacity, you now know what he means. Providers and the companies are bumping into limits of how much inference they can serve with the GPUs they have. Understanding the costs and trade-offs helps you design smoother, more reliable systems. Number six, we have tokens and context windows. When you use a AI model, you'll hear a lot about tokens. A token, it's just a chunk of text, usually a word or part of a word or a punctuation that the model processes. So, a chunk of text that the model processes. That's all a token is. And you can actually go to OpenAI's tokenizer tool and see exactly how tokens are broken down and counted. I'll put a link to that below. And then the context window is how many tokens a model can handle at once. Think of it as the model's working memory. So things to consider as a developer here are cost. API pricing is based on tokens. More tokens equals higher bills. You have to consider limits. So a small window means you can't feed long documents or maintain a long chat history. And then app design. You may need to chunk, summarize, or trim input to fit under a limit. Now how big are these context windows today? Well, GBT5 goes up to over 200,000 tokens, which is like a few hundred pages of text. Google Gemini 2.5 Pro is up to 1 million tokens, basically book- sized. And I think clawed is around 200,000 as well, with maybe more with the newer models. And an important note is that the context windows refers to the combined total of input plus output tokens. All right, so the context window is the combined total of the input and output tokens. So, if your Gemini input is 900,000 tokens, there's only room for 100,000 output. As a developer, choose larger context windows if you're building apps that handle long PDFs, conversation history, or rag pipelines that need lots of context. And then stick with smaller windows if your use case is short chats, queries, or if you want faster responses and lower costs. Now, number seven is guard rails. Now, when people talk about guard rails in AI, and you will hear this term, they're talking about the filters and rules that decide what a model will or won't say. And you'll run into them in two main places. First, from the AI provider. If you're using OpenAI, Anthropic, or Gemini, and your prompt gets blocked or redacted, that's a guardrail. On these platforms, these are built in, and you can't turn them off. That's why sometimes you'll see the model reply, "Sorry, I can't help with that." And then second, you'll need to deal with them in your own app. So in your own app, you can layer on your own guardrails with tools like guardrails AI or lingchain. This might mean forcing JSON output to follow a schema filtering out profanity or maybe blocking topics your product doesn't allow. And a couple of things to note as a developer here since provider guard rails are non-negotiable. Design your UX so refusals don't break the flow, meaning wrap refusals in friendly, helpful messaging or maybe give alternatives when refusals happen. But on your side though, add whatever rules you need for structure, safety, and compliance with your particular app. Number eight is function calling. One of the most practical features in modern AI APIs is function calling. And you may think I'm making this up, but you can actually go and read OpenAI's function calling guide. Instead of just generating text, the model can go and call a function that you define. For example, you register get weather passing in city as an argument. And if a user asks, "What's the weather in Paris?" The model doesn't guess, it outputs structured JSON saying call get weather that function with city equal Paris. So call get weather passing in Paris as the argument. Your code runs a function gets the real data and the model can use it in the reply. Now why do you need to do this? Well, first it's standard in APIs. OpenAI, Anthropic, and Gemini. They all support it now. Second, for structured output. Instead of crossing your fingers with prompt hacks, structured output gives you solid, predictable JSON. your app can work with. And third, you can trigger real actions. This is how AI can actually kick off workflows, send an email, or update a database, not just chat. And where are these important? Well, AI agents use function calling under the hood to chain multiple steps together. And then you've definitely seen it with MCP. So function calling is the building block that makes AI interactive and more predictable. It's how we can move from chat bots to real assistants that can do things, not just talk about them. Number nine is memory. So when people say AI has memory, it sounds nice, but it's not built into the model. By default, models are stateless. They only know what you send in that one request. And if you want memory, you have to build it yourself or use some out-of-the-box solution. In practice, memory just means saving past interactions somewhere, maybe a database, a vector store, even session state, and then feeding the important pieces back in on the next request. So, you prompt the model, it responds, and in your next response, you need to include the history and keep tacking it on like that or pulling it from somewhere to keep a memory of the conversation as you continue to interact. And memory is super important because it's what makes chat bots feel personal and consistent. And you'll have to decide how to store it, whether it be full transcripts, summaries, or embeddings for semantic recall. And also remember, you're bound by the context window. So, memory isn't endless. So when someone says AI has memory, what they really mean is the developer engineered persistence. And then finally, number 10, cost and rate limits. One of the first things you run into when building with AI APIs is cost and rate limits. Here's how it works. Most providers charge by tokens. Every word you send in and every word the model sends back costs money. So long prompts, giant documents, or using huge context windows all push your costs up. And then there are rate limits, which are caps on how many requests you can make per minute or per day. As a developer, you need to consider keeping your prompts lean. Cut the fluff, summarize history, and don't send more than you need. You'll need to also think about batching and caching. Don't pay twice for the same call. Reuse results. You'll need to think about choosing the right model, the big expensive ones for heavy lifting and maybe smaller ones for quick tasks, and then retries, back offs, and maybe cues to handle limits gracefully. so your app slows down instead of crashing. So cost and rate limits actually shape how you design your app. So you'll need to plan around them early. All right, that was a lot. So are you familiar with all 10 concepts? If so, great. I think you're adapting well to this changing industry. If not, now you know and now you're better off making more educated decisions in your IT role. If you found this video helpful, give it a thumbs up. If you haven't subscribed to the channel, consider doing so. And I'll see you in the next video. [Music] [Music]

To learn for free on Brilliant, go to https://brilliant.org/TravisMedia/ . You’ll also get 20% off an annual premium subscription. AI is becoming core knowledge in modern software development. Even if you don’t specialize in ML, you’ll be asked to build, integrate, or maintain AI features. This video servers to explain 10 essential machine learning and AI concepts for developers: model parameters, quantization, embeddings & vector databases, retrieval augmented generation, inference, tokens & context windows, guardrails, function calling, memory, and cost/rate limits, so you can ship reliable, cost-efficient AI features with confidence. Resources mentioned: Blog: Model Parameters (2B vs 7B vs 40B) → https://travis.media/blog/ai-model-parameters-explained] Blog: Quantization (4-bit, 8-bit, VRAM math) →https://travis.media/blog/ai-model-quantization-explained/ Tokenizer tool → https://platform.openai.com/tokenizer Thanks Brilliant for sponsoring this video Chapters 00:00 Intro 01:00 1 - Parameters 02:09 2- Quantization 03:24 3- Embeddings & Vector databases 04:52 Sponsor 06:10 4- RAG 07:28 5 - Inference 08:15 6 - Tokens & Context Windows 09:58 7 - Guardrails 11:01 8 - Function Calling 12:19 9 - Memory 13:17 10 - Cost & Rate Limits 14:15 Did you know all 10? 🎥 Watch These Next 🎥 https://youtu.be/uDcb12CqoR4 https://youtu.be/EMWNZtCYg5s https://youtu.be/jUOysN-rcyQ FOLLOW ME ON Twitter - https://x.com/travisdotmedia LinkedIn - https://linkedin.com/in/travisdotmedia FAVORITE TOOLS AND APPS: Udemy deals, updated regularly - https://travis.media/udemy ZeroToMastery - https://geni.us/AbMxjrX Camera - https://amzn.to/3LOUFZV Lens - https://amzn.to/4fyadP0 Microphone - https://amzn.to/3sAwyrH ** My Coding Blueprints ** Learn to Code Web Developer Blueprint - https://geni.us/HoswN2 AWS/Python Blueprint - https://geni.us/yGlFaRe - FREE Both FREE in the Travis Media Community - https://imposterdevs.com FREE EBOOKS 📘 https://travis.media/ebooks #ai #machinelearning #selftaughtdeveloper