Explore AI Programmatically

0:00Hello and welcome to the AI-Agentic Coding ChatGPT Cursor, Clod, and Co-Pilot course. I'm excited that you're here. When most people think of AI, they think of a chatbot window that spits out fluent, correct-sounding answers, helpful but not always correct, and it hides the bigger picture. When it comes to programming, the power of AI can be a bit overwhelming, and at the same time it can be welcoming to a wide audience, anyone from software engineers to complete beginners.

0:34Before we talk about the scope of this course, I did want to say that this is a beginner course. Meaning, if you have some experience programming and want to start using AI to increase your existing programming skills, then this is the course for you. But it's not entry-level. And by that I mean, if you don't have a programming background, this might not be the right course for you. But no worries, I have a course just for you on VibeCoding, and I'll explain that in just one second. First, let's check out what's included in the course, what's in scope and what's not.

1:09This course is about understanding the basic prompt engineering skills for programming. For example, when to use one model over the other for programming. And we'll talk about how to install and use different AI coding tools. So keep in mind that this is a mini-course. I'll show you that this is part of a series of AI mini-courses. So we're not going to get really deep into any one topic. But if you want me to create a course for, let's say, cursor or cloud code, just leave it in the comments.

1:40We read those comments and those will give us an idea of what courses that you're more interested in. This is more of a mini-course where we explore all of the different software, how they work, This is a mini crash course on prompt engineering as it applies to programming. We're not going to learn about programming in general. I have a course on VibeCoding instead. I'll show you that in the next slide. And there are no tutorials on how to build AI chatbots. So I did use the word agentic, which is agents, AI agents, but we're not building those.

2:13We're going to use existing programming AI agent tools. Again, we're not going to use APIs in this course because this is a mini-course. But if you want to go deeper into any one of these and include APIs, please let us know in the comments. So when I refer to APIs, I mean, we're not going to use computer to computer connections to perform any kind of AI programming other than that built into tools like Cursor or GitHub Copilot and so on. And like I said, this course is part of an AI mini-series.

2:46And this is the course that we're on now. However, if you don't have any programming experience, I definitely recommend the AI VibeCoding and Security course. Here's why. First of all, if you don't have any programming experience, you can ask ChatGPT to give you code and you can paste it somewhere or execute it and create a game. And some people are actually creating businesses doing this process because, well, you have business ideas, you maybe have great ideas, but you don't know how to program.

3:18And VibeCoding allows you to ask the agent or the AI tool to program for you. When you do that, there are a bunch of security issues that come up and that's what we're going to address here. It's like a crash course on how to do VibeCoding safely. And here, this is for software engineers or people that have a programming background. Let's say you finish this course. This is a good next course to take. But if you're a software engineer or you have a programming background, this is a good course to learn how to use the different tools like ChatGPT, Cursor, Clod, Copilot.

3:52And one quick caveat, ChatGPT, we don't really use that for agentic coding, but it does have a purpose and we're going to use it to learn different concepts. But ultimately, it's not for agentic programming. It's more for planning. More on that in the course. And so what are all these other courses? So here, prompt engineering is directly tied to this course. I'm going to give you a quick crash course in prompt engineering as it applies to programming. But I highly recommend taking this course because we all talk to the chatbot in different capacities.

4:26It's not always for programming. And when you do that, it will hallucinate, make things up and drift. If you don't know how to talk to it, then it makes it a lot more difficult. And in this first skill, we're going to talk about AI programmatically and explain the different types of software and give you a working mental model of how AI works, which lays the foundation for prompt engineering. But I will give you a crash course here in case you already have a little bit of a background. And if you already know prompt engineering, you can go straight to the AI coding tools.

4:58If you're working with Microsoft and you're curious about Microsoft Copilot, which is different than GitHub Copilot, this is a great course to take. If you're a business leader or an executive or you want to launch your own AI product, this is a good one to take as well. Now here we have two courses that are very similar, but for different audiences. AI compliance, privacy and copyright is a very important subject. And this is the technical version here for developers. And this is for a non-technical audience, HR, legal and IT.

5:28And finally, we have AI for productivity. This is for anybody. And it's very similar to what you might do here, but it's non-tool specific. So it's tool agnostic. This one up here, this is all Microsoft. And a little bit about me. My name is Jonathan Barrios. I teach data science, machine learning and deep learning. And all of this can fit under the umbrella of data science. But now that we're in 2025, it's really now called AI data science. I blend data science and AI engineering into one field.

6:02And I've also worked with AI and built software as a service applications, many different AI applications and even streaming platforms. Last but not least, I've been teaching for a while at top platforms from Treehouse to Thinkful and Chegg. And now I'm happy to be part of the CBT Nuggets team. And if you want to find me online, you can definitely do so at LinkedIn here at Jonathan-Barrios-AI. And my website where I occasionally publish different posts. There's one there on vibe coding, if you want to read that.

6:34And this is an important one. People have mixed feelings about X. The reason that I'm there is because that's where the AI community is. If you don't want to sign up for a newsletter to keep up with all of the developments in AI, XAI is a really easy way to do that. Furthermore, you can directly communicate with the greatest minds in AI directly on this platform. I do not like social media personally. I don't use it. However, in this case, it's kind of working well. So the way that I do this is I follow only people that talk about AI and then I ignore everybody else.

7:08That's the way that I do it. And if you want to follow me, I promise it's about AI data science. And that's my handle, AI underscore data underscore science at X.com. All right. Now, moving on to our first skill here. We're going to zoom out and look at AI as a whole. And we're going to think of it in terms of software, meaning what is AI programmatically. We'll discuss different types of software. First, we'll explore what is AI because it's not one thing.

7:40Many people think that it's the chat bot. That's actually generative AI and that's just one subdomain in AI. So if that's what you think, then this is going to be very illuminating. But if you have a good handle on this, then it might be interesting to learn about the different types of software. For example, software 1.0, 2.0 and 3.0. 1.0 is traditional. This is machine learning and deep learning, and this is generative AI. And there's a good reason why I explain it this way.

8:10In short, we're framing it this way to keep you from overcomplicating things. There are many tasks that still belong to traditional programming. These are simple rules, but here we're going to build a deep neural network in this skill. And these are models that you build. This is machine learning and deep learning. And here, this is when we talk to a chat bot. That's generative AI. And that's what we use for agentic programming, right? We're using an AI agent, a chat bot, to do programming together using some kind of a tool.

8:42And then we'll talk about guardrails. Now prompt engineering, just the idea about human in the loop. AI can't do it by itself. It needs us right now. And this is a very important concept. And we can use this as a safety guardrail. And then finally, we have a challenge. These challenge sections are for you to test your knowledge, meaning identify any knowledge gaps before moving forward. That way, every successive skill will make sense and you'll get the most out of it. Let's say that you already know what AI is.

9:14You know what software 1.0, 2.0 and 3.0 is. And furthermore, you know prompt engineering, well, you can just skip those sections, right? Definitely take the challenge to see if you understand that skill. And if you do, move on to the next one. And that's totally fine. Here's why. I made this very accessible. So you could be a beginner or you could be intermediate or advanced. It really depends on where you're coming from. So if you just need to learn those tools, then the last three skills are going to be just for you.

9:45If you need to ramp up to those first three skills, I've included what is AI programmatically, prompt engineering, and then some fundamentals and how to use chat GPT for development. Definitely don't use it for code. We'll talk about that in the third skill. So that should give you an idea of what we're going to do in this skill. And I'll see you in this very first video here. What is AI?

0:00Welcome back. In this video, we're really just answering the question, what is artificial intelligence? And like I said before, if this is something that's familiar to you, then go ahead and skip to the next video. Here's how I like to talk about artificial intelligence. First of all, it's not all chatbots. It might seem like that. This is just one slice of generative AI is this one slice, but there's many others. And artificial intelligence, it's really just the umbrella term. It's the box that contains all of the different kinds. So the first subdomain of AI is machine learning.

0:34There are older versions that are rule-based. These are expert systems where an expert would give their knowledge and create a knowledge base, and they would use that with the AI tool. So as a rule-based AI, it's very early AI, but it's not the same as machine learning. Machine learning and deep learning is when the models start to learn from the data on their own without an expert. So we're not going to talk about expert AI, it's an older form of AI, but the first official domain for our example is machine learning. And these are really just algorithms, right? This is where the model can learn from the data. So far, we talked about rules, search. These are the older forms of AI. And here's machine learning, and now we have deep learning. So deep learning also learns from data. And the difference here is that machine learning really has to do with algorithms.

1:30That's how it learns from data. And there's these different learning styles such as supervised, self-supervised, and unsupervised, also reinforcement learning. So these apply to both machine learning and deep learning. So whenever it says learning, there's some kind of learning. But what's special about deep learning is that it's software modeled after the brain. So you might hear terms like deep neural networks. Well, that's what we have in our brains. And this is software that's written to work using these neurons. So neurons will either push information forward or they won't. So we use software to write artificial neurons, connect them together in a big network in a very simplistic way. You can think of that as deep learning. The takeaway I would say is that it's software modeled after the brain, not necessarily algorithms. All right. So now we see that these two, machine learning and deep learning, are learning from the data and how deep learning is modeled after the human brain using those neural networks. And then we have generative AI. So generative AI is actually built using deep learning. And these are the chatbots that you see whenever we create images or videos

2:46or audios. These are all deep neural networks built with deep learning. But they are under the hood. So the difference is that deep learning will make some kind of prediction. But you can use deep learning to create a generative AI tool that is really good at predicting the next token. And a token is a word chunk. So like info, armation, so information, or maybe another word like D and lux. Those are two tokens. So these are word chunks. So it can predict word chunks so well that that's what it's doing when you're typing into a chatbot. It's literally completing the next token. And that's a whole type of AI called generative AI. It can do that with pixels.

3:29It can do that with audio, and so on. So what do we get? We get all these modalities from all of the different subdomains of AI, such as vision models, speech, natural language processing, computer vision, recommendation engines, robotics, and more. Now we can say that the different kinds of AI, including machine learning, deep learning, and generative AI, work together to bring us all of these use cases. So facial recognition, this is using computer vision. And computer vision is also used for self-driving cars. You can see that it's identifying every object here, car, tree, person, sign. And here, it's focused to faces. But these are both vision models. Again, these are built with deep learning. And robotics might be a combination of machine learning and deep learning.

4:22Same thing here. When you're working with intelligent document processing, this might also include generative AI on top of machine learning or deep learning. It really depends on how you're using them. And fraud detection could be machine learning. That is a classic machine learning problem. But it can also be augmented, depending on the case, with deep learning. So the takeaway is that AI is definitely not one thing. It's different things. But I don't want to overcomplicate things. Because when you think of this, and you're thinking in the terms of programming, how is this really helpful if you're not going to be building these things?

4:58There's a much better way to understand AI and those subdomains by looking at it programmatically. And that's what we're going to do in the next video.

0:00Welcome back. Now we're going to shift some gears and talk about software and three types of software. If you don't know Andrej Karpathy, definitely follow this person on X because they are directly responsible for building a lot of 3.0 and improving 2.0. They worked with ChatGPT at the very beginning and OpenAI and has contributed across the board. And this is a great mental model that I learned from Andrej Karpathy by following him on X and then seeing this video of a talk. So you get to see all of these talks and he posts a lot of really great stuff. And so this, I thought, wow, this is a great way to explain a lot about what AI is because you're not bogged down by all of the subdomains and the complexities that come with each one because they are in depth. They're not very easy to understand conceptually by their titles. But when you think of it this way, it really opens up doors. Let me show you what I mean. Software 1.0, as we discussed, you might do in a terminal or an IDE. And this is where you program. And these programs are basically rules that you write by hand, by typing. It's some kind of program or code that you write and then

1:20you get this behavior. Think of it like this. In software 1.0, the logic lives in the code that you write. If this, then that. And the key word here is deterministic, meaning that you're going to get the same output. Even if you're doing something with a random generator, you're still going to get the same random output every time. Right. If you're saying one plus one is two, you're always going to get two or whatever that output is, depending on how you write that numeric data type. It really depends on programming languages. But the key here is deterministic means you're always going to get that same answer. It's not just going to start to guess and go off course and drift and hallucinate. That's 3.0. We'll talk more about that.

2:04So software 1.0 is easy to test and it's great for clear choices. Think about routing a ticket after 24 hours or blocking logins after five failed attempts. You could clearly write that in software 1.0. But what is software 2.0? Here you're writing the code, but the decision logic is learned from examples. And we'll talk about this in depth. These are rules that are built with weights in the deep neural networks. So here you can see this is software modeled after the brain. We're more talking about deep learning, but this also includes machine learning because they both learn from the data or examples. You give the system labeled past data, meaning historical data, and then it learns some kind of mapping, right? Using weights. How important is one piece of data or one shape or one token in the context of the output of the goal?

3:03So you train it, you can also fine tune it, and then you get this output. But it's learning from this training data. And this is perfect for estimating priority one through five or spotting churn, computer vision, or robotics. Meaning you can pass it a bunch of videos of driving and then the model can learn what driving is. It can identify objects and also know when to go left or right. So here's how it works. The photons go into the camera and then it turns that into a driving action. So that's an end-to-end machine learning model. You can call it more specifically deep learning or you can say it's computer vision. You see what I mean? We can get lost on these labels, but what's happening is that it's predicting the action based on what it sees. So it's learning from the training data. That's how it learns how to do that. I promise this is going to be really simple by the end of the scale, because I'm going to show you demos for each one, especially this, we're going to build our own classifier, meaning we're going to use a hot dog and a hamburger and create a bunch of training data. And we're going to build our own deep learning model without code, because it's easier to just understand, okay, we created this label data, we train the model,

4:20and then we were able to show it a picture. And it was able to identify it make a prediction on what it was looking at, which is simpler to computer vision. So that will be totally clear by the end of this scale. And then we have 3.0. And we're really working with prompts. And that's the meat and potatoes of this course. So what we're doing is we're steering the behavior. So we're steering this 2.0 model to get an output. Think of it like this, instead of hand coding every step, or instead of training a model using training data, you simply describe the role, the goal and constraints, or you just talk to it in plain English or plain language. And then the model gives you an answer that could be text code, a plan, and now images and audio and video, and then you can review it. This is exactly why we're going to use agent decoding. This is where agent decoding lives in software 3.0. You combine prompts with tools like search tests and linters, and then we have to add check. So we know that the model is correct. And the reason is it hallucinates. But the hallucination comes from the fact that people talk to these generative AI models,

5:37like they're talking to a human. And when you do that, that's where things go south, because it's not a human. You have to understand how it learns, and that's what we're going to learn in software 2.0. We're going to understand how these 3.0 models are built. And when you know that, you can literally program using plain language. So 3.0 is the hottest new programming language, English. And that's a quote from Henry Karpathy, because 3.0 just uses plain language to get an output. Whereas 2.0, you have to write a lot of code, train models, get training data, and then train the model, and then optimize the model, and then you get an output. But that's a lot of work. With software 3.0, you do it in plain language, which might seem super easy, but that's a trap. You need to program in plain language, and that's why I'm explaining it this way. Think of 3.0 as a co-pilot that generates code, and you decide whether to accept it or not. And if you're asking, well, how do we program in plain language? Well, that's prompt engineering, and we're going to talk about CRE, shots, constraints, and retrieve snippets. These are called facts. And this is how we program in

6:53plain language. So not just English, that's what we're going to do in this scale, but it can be many different languages. All right, so now we know what software 3.0 is. And to review, software 1.0 is traditional programming. If you go into a programming software or an IDE, like Google Colab, Visual Studio Code, and you type one plus one, and you're working with Python, it's going to give you the integer two. And no matter how many times you run that, you're going to get two. One plus one is two, right? You can say print hello world, and you're always going to get hello world, however it was written in that print statement. Software 2.0, that's when we get into these, hamburgers and hot dogs. We create a bunch of training, and then it learns from the training data that's labeled, meaning a bunch of pictures of hamburger, but they're labeled hamburger. And then here, they're labeled hot dog. It knows this is a hot dog because we labeled them. I'm going to show you how to do that. And after it sees n number of training data, it learns, it starts to make predictions to get more and more accurate. So depending on the quality of the data and the number of samples, that's how good it can make a prediction. I'll show you how that works.

8:09And finally, 3.0, we program in plain language using prompt engineering. That's what we're going to do in the next skill. We're really going to do a micro version of prompt engineering, which is actually a course, right? So I would definitely recommend taking that prompt engineering course to learn how to speak to the model using plain language. And then we can apply it here to agent decoding to get exactly what we want from our models. All right. On that note, I will see you in the next video where we take a look at software 1.0.

0:00In this video, we're going to write the rules, meaning we're working with software 1.0. Rules by hand, which is really programming or code that then gives us the behavior that we're looking for. This is going to be fast, clear, and easy to build. After you extract the text from an image, and in this demo, we're going to identify whether a document image is either an invoice or a receipt. After you extract the text from the image using OCR, OCR is optical character recognition, so we're taking the image and then turning it into text using OCR, then we can scan for high signal words like invoice or receipt.

0:44If those appear, then you can return a label with near zero ambiguity, meaning software 1.0 is perfect when accuracy needs to be predictable and testable. You can do unit tests, you can use a code review in five minutes, and ultimately, you can ship it with high confidence because we're using explicit rules. There's no learning. When the learning happens, well, guess what? Sometimes we make mistakes and so do the models. If you want to change the behavior, you simply edit the code. We could create a greeting based on the hour, but I think this example is going to be a little bit more fun.

1:19All right, so let's do this in Google Colab. Since I'm really in the data science field or now called AI data science, this is a common tool that we use. If you're more familiar with an integrated development environment, this is very similar, but I have access to GPUs in Google by using this and it's for free. You can also use AI, but I don't necessarily use the AI here. I just use this as a programming environment that has all the packages and libraries and free GPU access that I need.

1:51But don't worry, we are going to get into cursor and Visual Studio code so that we can access GitHub Copilot and we'll also take a look at Cloud Code. Those are the tools that you're going to want to use for agentic coding. This is just really good for demoing and teaching and then saying, look, here's software 1.0. Let's build it together. I can just hit shift enter and it executes. So it's really great. If you've never seen this before, definitely worth checking out and adding to your wheelhouse of development environments.

2:22So first we want to state the rule in plain English. Okay, so let's create a function. We're going to create a function called label doc, and then inside it's going to take in an OCR text, which is going to be a string and the output is also going to be a string. I've been watching too many Lord of the Rings. I've spelt it orc. So it's OCR. So I changed it here and here. I spelt it orc twice. So what we're doing here is just turning it, turning that text into lowercase so that we can scan it. And then now we have, if this, then that this is classic 1.0.

2:54If you find the word invoice in the text, then return the string invoice. And then we've successfully classified that this image is now an invoice. Okay. And this is all programmatic. When we use OCR, that is programmatic. It's not using images that are labeled like we do when we're working with 2.0 and feeding it training data. But we need to also handle the receipts. So we can say the same thing, meaning if receipt is in the text, then return receipt.

3:25However, if we don't find it, we return unknown. As you can see, these are very simple rules. You could say, well, you're using plain language. It's not plain language. I'm using plain language right now. This is human interpretable language, which is a programming language. It's pretty close. And I totally get it, especially with Python. It's kind of like almost plain language. So I totally get that train of thought. But really, this is programming language for humans so that we can translate this into a type of language that gets really granular into zeros and ones.

4:02That's what the machine understands. So we're not going to type in binary and zeros and ones, but instead we use this programming language. So it's a nice little translator, right? When we get to 3.0, there's no translator. You're just using plain language. And that's why you need prompt engineering, because you might just start talking to it like a human. And here, let's go ahead and run this. Since it's a function, it doesn't do anything. But first it has to connect, and then it runs. As you can see, in zero seconds, nothing happened. Right. So here I created three examples. So invoice, receipt, and unknown.

4:34We want to scan this to see if this works. We don't know if it works yet. This is a test invoice. It is labeled invoice. So here I just use an F string to return what was inside. And we can see that it clearly has the word invoice that was turned into lowercase. And then we were able to say, OK, return invoice. So this is always going to be deterministic. By that I mean, if I run this, I run this, and I run this, no matter how many times I do it, we're going to get the same output. All right. So that's it for software 1.0. If you already knew what it was, then definitely feel free to skip these videos to match what you know.

5:09But you may not know what deep learning is, and you may not know what a neural network is, or how to train a model. And that's what we're going to do in the next video with our hot dog and hamburger labeled training data. See you there.

0:00Welcome back. In this video, it's all about software 2.0. These are rules that are in weights. Think of it like this. So we have an input, and then we have an output. And these are neurons, artificial neurons that are interconnected, and they create these neural connections. And this is a neural network. So let's say we give it a picture of a hot dog, a bunch of them, right? So we give them a bunch of different pictures, and maybe we do a hamburger. And then here, it's going to predict hot dog. And so each one of these neurons has a weight. So how important is this feature or this part of the model, this part of the information that relates to the input, that's going to now relate to the output. So we create weights. And you might've heard that in these different companies, and you might've heard that term, like we don't publish our weights or what is an open source. So OpenAI was supposed to be an open source company, but it's not.

0:59So it's kind of confusing. After it was founded, they kind of changed their mind. They're like, okay, we can't do this. But if it was OpenAI, then the weights, we would have access to these weights. If you want to find models that are open source, then you might want to go to HuggingFace. That's an open source platform with open source models. So OpenAI is not open source, even though open is in the name for that very reason. And you will see them on X and different platforms talking about their weights. So that's what they're talking about. And we're going to create our own tiny classifier using teachable machines. So no code in this case, and we're going to collect 20 to 50, maybe even a hundred samples per class. And if you don't have a hamburger and hot dog, you can use your hand and you can just simply do like one or two, and you can create class one, class two using that. Let me show you what I mean. But first we need to know that we're training, and then we get this preview for live classification.

1:56And the takeaway here is a software 2.0 learns from data or learns from examples and the weights change during training. So it gets better and better and better. And it gets all the weights that are in each one of these neurons just right so that it can classify live with a high degree of accuracy. All right. So here is software 1.0 and here is software 2.0. We're going to do this with teachable machine and then click on, get started. And we're going to do an image project, but you could also do audio or poses, but keep in mind that images and poses are pretty similar.

2:32This one just uses a video camera webcam to continuously take images to, to see what pose that you're in using these little dots. But the image project is taking the webcam and then turning them into individual still frames. So they're very similar. And what might not be totally obvious is that audio also uses images. It's not like listening to the sound. It turns the sound into these visual representations of sound, and then does the same thing with images. So they're really all three are very similar. We're going to click on standard image model. And here we have two classes. I'm going to add another one. I'll explain why. Actually, let me do that after the fact so you can see why. So here, hot dog here, hamburger. But if you don't have these, you can easily say one and two and just use your hand to create those images, right? Just pointing one and two. Now we need to create training samples. I'm going to click on webcam and I cropped it so that we can just hold this up, get a good visual of the hot dog. So now I'm just going to hold this down and make sure that I get a hand 100 samples. OK, 105. That's fine. Now let's do the same for hamburger. All right. So let's try this. Let me get it there. All right. And move back just a little

3:49bit. Whoops, I've got too much. Let me try that again. OK, so let's make sure that we get about 105. Perfect. You might be asking, well, why did you do 105? Exactly. Well, if you have too much of hot dog, it's going to prefer this. And that's bias. So training data can easily introduce bias if you have a lot of hot dog images, but very few of hamburger. Now what we need to do is train our model. If you look at learning rate, all of this stuff, this is the stuff that we do programmatically and I teach courses on deep learning and we do this all in Python, writing it all out. But here you can just like click on it, but we're going to leave these defaults. But I wanted to show you that this is what's happening behind the scenes. So now we can just say train the model and then it'll prepare that training data and pass it through the neural networks multiple times.

4:39So here it's like, whoa, that was very quick. All right. So I'm not a hamburger. If I move out of the way, you can still see it doesn't know what it's doing. And that's because we haven't given it. It's not fair. So let me crop this first. OK, now that I've cropped it, it's like, oh, the background is a hamburger. So we need a background class. I'm going to say here background or say nothing. Right. Maybe background is more semantic. And now I need a hundred samples. Let me move out of the way and I'm going to do one hundred and five samples of the background. Perfect. And now I'm going to close the webcam and then train the model again.

5:13We've just changed the training data. So now we're going to remove bias or, in fact, not necessarily remove bias, but we're going to add more training data so that we get a better model. And now you can see that it's predicting that this is a background. One hundred percent. If I go here, it thinks I'm a hot dog. I'm not a hot dog, but, you know, we're not trying to classify a human face. That would be facial recognition. So let's try it. Let's go over here and look at that even just a little bit. It knows this way, that way, every shape, even this way, no matter which way that I point it is like that is a hamburger. Now let's try a hot dog immediately because it's a cute hot dog. It knows immediately that it is. Let's see if we can go down here. Yeah, it's pretty accurate. So it knows that it's a hot dog. And so if I go back in here, it thinks that I'm a hot dog. I'm not a hot dog. But that's biased because we don't have any images of me and it's not trained to classify a human. You can also export this and you can see a little bit of code here. But this is TensorFlow for JavaScript. And here's TensorFlow. I have a course on this if you're interested in taking it and learning how to do this from scratch. You can also download the model and there's TensorFlow Lite if you want to put this on a mobile application like Android and so on. And that's software 2.0. As you can see, it's totally different than software 1.0 where

6:34we do all of this. In fact, we can create a classifier using Python like this to create a 2.0 model. But the difference is that even though I am using Python and code, I'm creating training images and then feeding them into the model. And then the model learns from that data. So even if you use programming languages for 1.0 and 2.0, the distinction is here, there's no learning. We told it to go lowercase, scan the word invoice. And if you find that lowercase invoice, then say this.

7:10If X, then Y. When we did this for teachable machine, even though I may be using code like this, I'm still feeding training data like hamburger and hot dog images to the model. And then the model learns. So I could go over here and go here and then download all those samples here and here. So this might be a cool way to like just use this to create samples. And then you can go over here and then write from scratch a TensorFlow computer vision model using whatever you wanted to do. You could use convolutional neural networks, recurrent neural networks, and then pass all that data in here. And then you would get the same behavior. It would be able to classify the hot dog just like this. But instead of that way, we would do it programmatically and just give it one image and say, what image is this? And it would say hot dog. And finally, we have software 3.0 in the next video. See you there.

0:00This video is about software 3.0, meaning prompts as plain language programming. So we're programming in English, but it can be in plain language and many different languages. So what we're going to do is solve the same problem that we did before with hamburger and hot dog, but this time we're just going to say, hey, chat GPT. What is this image? And it's going to just clearly know that it's a hot dog, like there's no way that it's not going to know that it's a hot dog. The reason is it's been trained with way more hot dog and hamburger images than we fed it in that simple model that we did.

0:34It's using like a gigantic amount of training data. It's a very powerful model, but it's a general model. It knows a little bit about everything or a lot about everything really, but that's why it makes stuff up and guesses and gets confused. And that's why prompt engineering is so important with the hot dog and hamburger. All it knows is hot dog and hamburger. If you give it something else, it's just going to be like, I don't know. So we could have added another class. If it said, if it doesn't find a hot dog or hamburger, it could say, I don't know, instead of the unknown background, right?

1:07It could just be like, I don't know what this is because I'm not trained on it, but it's really good at classifying a hot dog and hamburger because that's all it knows. And you can take these software 3.0 models and fine tune them. So they're really good. You can give it a bunch more data on specific tasks, and then it becomes a specialist. But you can also do that by telling it, I want you to act like a Python programmer that is careful and that does testing. The minute you do that, you are steering that model to become a specialist just through English.

1:40And that's the power of software 3.0 on real quick. Why am I saying software? You can use an API and create a website that uses an API and people could talk to a specialist. So like I could create a model that's a guitar instructor, for example, and then you could have a lesson with it. I could even train it on my face and my language or the way that I speak and then teach guitar lessons like that. That's something that people are sort of doing. There's a lot of content on X where it's not even the person, but they say, this is the AI version of myself.

2:15But I do read the comments. So all of this stuff is pretty wild. So the essence of software 3.0 is that you program using these prompts. But while 3.0 is fast and flexible because you're using prompts and plain language, it's not a substitute for verification, meaning you have to make sure that it is accurate because it's prone to hallucinating or making things up and guessing. So always treat that output as a draft because what we're doing at runtime is steering that behavior.

2:46So when you're steering, you don't have complete control. So these prompts equals runtime instructions that are in plain language. You're not actually changing the weights, but they condition the behavior in the context. So if you give it a role, it's going to be steered into that very narrow area of data. And you can do this with constraints and examples as well. And you can also keep facts in the excerpts. So this is prompt engineering and you can use style and format to steer that model. And the goal here is shorter, steadier and paste ready outputs.

3:20If you worked with chat GPT or other models like Grok or Claude, you know that maybe you need to do this a few times. You're not going to get exactly what you want the first time. That's very common. If you do prompt engineering, you can get it on the first try because you understand how they were trained. And that understanding is I'm not just speaking to a human, I'm programming in English or whatever plain language you're using. And when you know that you're applying prompt engineering. So we're not doing software 1.0. And here we built our model without using code, which you could do.

3:54The difference is that here there's no training data. And if you're using a 2.0 model, you'd use training data, even if you're using Python. And this is clearly training data. But now here is software 3.0. So I'm going to go over here and I'm going to download all these samples. And now I'm going to upload it here into chat GPT. All right. So here's the hot dog. So this is programming in plain language. We're going to do this in the next skill. That's prompt engineering. And this is CRE context role expectation. So here it's food food classification.

4:25And here I'm going to say you are a hot dog hamburger classifier output either hot dog or hamburger. And then I'm going to add security here. So I don't want it to make something up. OK. So let's try this out. Scroll down. Well, I'm going to have to hit shift. Enter. Let me make this smaller. I just made it a little bit bigger so you could see it. But now you can see the little arrow and I'm going to click on that hot dog. And now we've got the same output that we got here. This hot dog 100 percent. And if you look at this, this looks kind of like programming.

4:57And that's the idea of prompt engineering. When you do this, you'll get the exact output that you want. And when you're building applications or you use somebody's application and they have an API in the background that's talking to chat, GBT, Grog, Claude or all these providers of these models, they do this because otherwise you can ask it some weird question and get a weird output that has nothing to do with the application. So it wouldn't be very useful. So prompt engineering is how you build those products.

0:00We have a short challenge just to make sure that you don't have any knowledge gaps. And the way that this works is that we need all this information to be solid before moving on to the next skill. And if you feel like you had this totally covered, then take the challenge just to make sure that you have all of these. And if there's any missing gaps, then go ahead and review the appropriate video and then move on to the next skill. But if the next skill for prompt engineering is something that you also know, skip to the challenge and just make sure that you have all of those knowledge gaps covered and then move on to the next skill. And as a reminder, this course is part of the AI mini series. And this is where we are now. If you felt this was a little bit too complicated because you don't have a programming background, you're new to programming or never programmed. I would highly suggest taking this skill just to make sure that this is a good next fit. If you do have a programming background, this is a great place for you. But I would also suggest AI prompt engineering to go deeper into prompt engineering.

1:00This is a fun skill and you'll learn a lot of foundational knowledge that will be covered here. And we can't get really deep into any of these subjects, even all of these cool tools, because this is a mini course. So if you want this to be a full course on cursor or a full course on, let's say, Cloud Code or GitHub Copilot, just let us know in the comments because we read those. And the more suggestions that we get, the feedback that we get, that gives us the data that we need in order to create these courses. And until next time, I hope this has been informative. And I'd like to thank you for viewing. Transcribed by https://otter.ai