Explore AI & Prompt Engineering Fundamentals

0:00Hello and welcome to the AI Prompt Engineering with ChatGPT, Gemini, and Claude course. I'm excited that you're here. Before we get started writing any prompts, we need to have a good idea of what AI is so that we can leverage how the prompts are generated to get the best possible outputs. But first, my name is Jonathan Barrios, and in this AI Prompt Engineering with ChatGPT, Gemini, and Claude, I want to lay out the scope of this course. So what's in it and what's not in it. So what's in scope? We'll understand how to craft prompt inputs to get the best possible outputs. And we'll make sure that we don't add any sensitive information into the models. We'll talk about why that's not a good idea. That sensitive information is also called PII. We'll break that down, and I'll be sure to unpack that throughout this skill. Super important.

0:56And we'll develop a reusable prompt toolkit for you. And if you are doing this for your job, then your team, this is really valuable. And here's why. It might be tempting to just go back to talking to these language models like ChatGPT, like you're talking to another human. But when you do that, you go back to the not great outputs. And as you progress through this course, you'll understand exactly what that means. That could also include completely wrong information because these models are really confident when they're wrong. So what's out of scope for this course?

1:30We're not going to talk about AI engineering. This is all no code and no tutorials on how to build your own AI chatbots. And we're not even going to use APIs. That means no use of computer to computer connections. And this course is part of an AI miniseries. And here's where we're at now. If you're thinking about launching your own AI product or you're an executive or a leader, this is a great course to take. And we start with an idea and take it all the way to deployment.

2:01In this course, we're really talking about prompt engineering, meaning how to program in English. We'll talk more about that. But this goes hand in hand with vibe coding, meaning vibe coding is for non programmers that learn how to program or leverage programming using AI. But if you're already a programmer, you might want to take this course, which is agentic coding. So you can think of it as a coding assistant. Here, you're heavily relying on the AI to do the coding for you. But here you're doing the coding, but having the AI help you. They're different roles. Eventually, vibe coding should become more like agentic coding. So if either one of these are interesting, I suggest taking this one first. And if you don't have a programming background, this one second.

2:49And if you do have a programming background, take this one next. And if you want to learn AI productivity, generally speaking, this is a great course. However, if you're working with Microsoft, Copilot is embedded into the whole ecosystem. And finally, if you are deploying and building a model for your organization, you might want to consider the AI compliance and privacy for the non technical audience, HR, legal and it. And when I say it, I'm talking about the non technical it fields.

3:20But if you are in the technical field, then this companion course, which is the same course, but for developers is a better path. So now that you know that this course is part of an AI mini series, let's move on to a little bit about me. My name is Jonathan barrios. And I teach data science, machine learning and deep learning. And these days, that term is now called an AI scientist. When you combine data science with AI engineering, this is a term that's going around. I've worked with AI and built many different kinds of applications, including SAS websites, AI applications and streaming platforms. I've been teaching for quite some time at top platforms, such as treehouse, thankful and check. And now I'm happy to be part of the CBT Nuggets team, you can find me on LinkedIn, my website, or x.com. And the real quick note about x.com, a lot of people don't like x and a lot of people love x. So really, for us, when we're talking about AI science, or learning AI, or prompt engineering, this is where all the best minds of AI are. And this is an easy way to stay apprised of all of the developments. I don't follow anybody else, I only focus on AI. And that's it. Because social media in general is

4:39just a time suck. But AI on x is really a great is a fantastic way to stay updated. But you have to curate your social media or it will waste a lot of time. And this is the first skill in the course where we're going to explore AI and prompt engineering fundamentals. We're really focusing on AI here. What is it? It's not just one thing. There's many different parts to it. So if you already have a good handle on AI, you might want to consider skipping this one and then jumping into the next skill. But to make sure let me show you everything that we're going to cover in this first skill. Number one, we're going to talk about AI and how it's not only one thing. It's many things. Then we'll talk about LLM. That's a type of AI. And these are chatbots. But you need to understand how they predict the next word, how generative AI works. So this is really about gen AI. And this is what everyone thinks AI is. But as we discussed here, it's more than one thing.

5:42And then we'll build a mental model, making it easy to understand what AI is and how to apply to the different types of AI. And here we're going to explore the three main types. And you'll even build your own AI model to distinguish between a hamburger and a hot dog. This could be numbers or anything, but this is called a computer vision classifier or a simpler way. We can just call it an AI model. All right. I think that's it for this video. And now that you know what we're going to cover, I'll see you in this first video on what is AI.

0:01In this video, we're going to answer the question, what is AI? Because AI is a big umbrella term, meaning it's not one thing. Another way to say that is that chatbots are just one slice of the pie. So day-to-day companies still use a mix of different kinds of AI. But to the general public, a lot of people still think that chatbots is the only type of AI. And in the context of prompt engineering, understanding the other types of AI, not just chatbots, is really the secret sauce to better outputs.

0:37Here's why. Like I said, generative AI, this is the chatbot part, is only one part. But AI, in general, is that umbrella term that we were talking about, which includes rule-based AI, search, machine learning, deep learning, and generative AI. But we could just simplify it to these three right here. Because rules are an older version of AI, and search is something that's also done in these three terms. So really, you just want to remember machine learning, deep learning, and generative AI.

1:11In short, these models learn from data. They're not like traditional programming. For example, if X, then Y. When we have that kind of programming, it's always going to return the same answer. That's called deterministic. These models are non-deterministic. You'll get slight variations in the output. So that's the first hint. These models are non-deterministic. And that's why sometimes they make up information. More on that soon. Another interesting thing to consider is that they all learn in different ways.

1:44Here are different learning styles. Supervised, unsupervised, and reinforcement learning. And when I said we're going to build our own computer vision classifier, that's supervised learning. Meaning we give it different images of hamburger or hot dog. And we show it an image, and we label it as hamburger or hot dog. That's supervised learning. Unsupervised learning is when you give it a bunch of images like this or this. I'm not defining them. The computer has to figure it out.

2:15So that's the difference between supervised and unsupervised learning. And we'll build our own classifier using no code at all. So it's a simple, fun way to understand the complexity of machine learning and deep learning. Specifically deep learning. We'll get into that. It's really fascinating. And finally, reinforcement learning. Think of it like Google Maps and an AI agent trying to figure out the destination. If it hits a wall, it gets a penalty. If it gets closer to the goal, it gets a reward.

2:46That's reinforcement learning. You could think of it as a robot trying to navigate a maze. And then we have modalities. Meaning these one, two, three styles of AI can do a bunch of different things. They're adaptable. But the takeaway for right now is that chatbots, which are generative AI, are simply one slice of the pie. But instead of thinking about them as machine learning, deep learning, or gen AI, we can think about them in terms of software.

3:19And you might be asking yourself, well, why am I going to think of software? The easy answer is this is going to give you a deep understanding of how to write a good prompt. Because you may not know it, but when you're writing in English, that's programming. But you don't know it. So that's software 3.0. But let's start from the beginning. What is software 1.0? We'll explore these in individual videos. And I'll show you step by step what it is. Software 1.0 is traditional programming.

3:49These are rules by hand. Meaning if X, then Y. And I'll show you programmatically what that means. But you can think of a game. Once you get to number 10, then you enter level 2. That's it. That's traditional programming. That's the software that we've been using before AI showed up and took the world by storm with chat GPT. At that point, everyone started to understand, oh, there's this new kind of thing. A chatbot. It thinks like a human. It's artificial intelligence.

4:19That's all software 2.0 and 3.0. Let's break it down. Generally speaking, software 2.0 is software modeled after the human brain. And that's why we use terms like neural networks. Because the human brain has neurons. And they're connected. And that's a network. And that's how we think. We connect our neurons. And the neurons will just pass information from one to the other to the other. And that's how we remember things. That's how we classify things. Like if I show you this right now, what is the first thing you think?

4:51Hot dog. You just use a neural network in your head to classify a hot dog. I'm going to show you the software 2.0 of doing the same thing. But as you can see, they learned it from us. So when you're talking to chat GPT, that is based on software modeled after the brain. And the technical stuff is that we train it and you fine tune it. And then you get this behavior. That's not so important. Just remember that they learn by themselves. Here, software 1.0, we tell them by using rules.

5:24And we code it in programming languages like Python or JavaScript. If you've heard of those, those are programming languages. And that's software 1.0. Software 2.0, while it may use a programming language to set it up, the learning happens because we created AI. Artificial intelligence where it learns on its own. And that includes machine learning, deep learning, and generative AI. Machine learning is the older style. And this is mostly algorithms.

5:55Deep learning is really where it gets into neural networks. And generative AI is built on top of deep learning. And, again, this is not the important part for prompt engineering. But now you know the history. Deep learning is really the one modeled after the brain. And to get to generative AI chat bots, well, that comes from 2.0 deep learning. And to keep it simple, just think of it like this. Traditional programming is 1.0. That's the coding that everybody was doing. Software 2.0 is when we build these artificial intelligence models that think by themselves.

6:29So you might be asking yourself, well, what is 3.0? 3.0 is rules that are prompts. So here we code it by hand. Here we use something called weights. But this is how important a piece of information is. And then the model learns on its own. Let's say by itself. Here we're using plain language or prompts to steer the model into behavior. Here it learns by itself. But here we can tell it what the behavior or the output that we want by talking to it.

7:02So now it should start to connect. You're literally programming in English. And if you're using a different language, well, you're still programming in plain language. But you're programming. And that's the takeaway. That's why I spelled it out like this. When you talk to a chatbot like a human, you're making a huge mistake. And that's why you're not getting awesome prompts. It's not a human. You're programming it. So you need to think like a programmer. And I'm going to make it super easy. You're not going to learn coding. You're just going to learn the fundamentals of programming so that you can use that in plain language to get awesome prompts.

7:38And we're going to use things like CRE, shots, constraints, retrieve snippets. These are all technical terms for right now. But this is going to become very clear by the end of this course. And your prompts are going to be awesome. So let's review everything we've done. So what we're doing here is building a mental model. Just an easy way to think about AI. So AI mental model that I want you to carry through the course. Software 1.0 is the classic programming. If this, then do that.

8:09Traditional programming, this is coding. Software 2.0 moves from rules into that neural network or software modeled after the brain. That's all you need to know. It learns from the data by itself. That's why it's called AI. And while it does train and you can fine tune it to get that output or behavior, these are technical things that are not important for the mental model. Just remember, regular coding, software modeled after the brain for 2.0. 3.0 is where prompt engineering lives.

8:41We program with natural language and that's it. It's built from the software modeled after the brain. And that's where these chat bots come from. So you're programming in English or whatever plain language you're using. And in the next video, we're going to make software 1.0 concrete. We're going to unpack it and I'm going to show you some demos. Then we'll move on to 2.0. See you in the next video.

0:01In the last video, we clearly outlined the differences between 1.0, 2.0, and 3.0. The takeaway here is not necessarily that we're using machine learning, deep learning, and generative AI, such as chatbots, but it's to really understand that historically we had traditional programming, and now there is software modeled after the brain, which is 2.0, and we have to build the models and train them and do all this stuff. However, software 3.0, which is built on 2.0, is programming in plain language.

0:34That's really the takeaway. And what we want to do right now is to make software 1.0 as clear as possible. In this world, behavior lives in the code. That means that you create rules by hand, and you're programming, you're coding, and then it creates the behavior. So the output of your code is whatever you created by hand, by coding, and then you get the output, which is the behavior. If you wanted a different behavior, you would simply just edit the code, and that's it.

1:05So we edit with rules. That could be if X do this or else do this. There's loops, there's comparisons, all kinds of stuff. But the takeaway is that there is no learning. They just follow our instructions, just explicit instructions that the computer follows exactly. And like I said, you change the behavior by editing the code. And I'll show you in something called Google Colab. All you need is a Google account, and you get this for free, and you can run code.

1:35But you don't need to understand the code or you don't need to run the code. I'm going to do that just to make sure that we understand exactly what software 1.0 is. And we'll use a demo. Maybe we'll use the greeting based on the hour. But then again, I could code whatever I want because whatever I write is going to be software 1.0, meaning I'm writing the rules. So I could write whatever rules I want, and then I'll get the behavior that I'm looking for. If my code is good, you have to be a good programmer. You have to understand programming.

2:05That's the only caveat for 1.0. And here is Google Colab. And I'm signed in because you can see my photograph here in the top right, and that's all you really need. I could share this with you, and I am going to share it with you in case you feel like programming or running it just to play around with coding to get a good understanding of what coding is. However, that is completely optional. As long as you have a Google account, it'll work. But if you don't, there's no need to open this up and try it yourself. So here, and this is called a code cell, and the reason we're using Colab is that this is the easiest way to show you software 1.0.

2:42Normally, there's a lot of setup. There's just a lot of technical stuff that goes along with it. But with Google Colab, I can clearly demonstrate software 1.0, and that's why this is such a good tool for this part of the course. So the first thing that people do when they learn programming is this. Hello, world. And if I run this, I can just push the play button or hit Shift-Enter, and it executes this code. But first, it has to connect to the cloud, and then it executes. No matter how many times I run this, I ran it three times now, and you can see it's counting the number of executions.

3:18That means that this is always going to be the same. So I could add a comment, which is what programmers do, and I could say, software 1.0 is deterministic. And if you looked up that word, it just means that we're going to get the same output every time. So if you look at that definition in this context, that's what it means. ChatGBT, on the other hand, may output different text every time you run it because it is non-deterministic by nature. Sometimes it might do it, sometimes it may not.

3:49We'll explore that soon in software 3.0. But what if I wanted to do some programming and I wanted to create a greeting based on the time? I would literally have to input my name. So I could say name and this input function. You don't need to know what it does, but I'm going to show you right now so that it's no mystery at all. I'm going to run this cell and it's going to ask me my name. So this little line of code means ask the user the name, save it in this variable name, and then print it.

4:21And then it prints it down right here. So it didn't learn anything. It just followed my instructions. I created an input, meaning create an input form so that the user can type in a name. And I want you to save that under the variable name. That means that you can reuse that name. So I can print it. I could change it into uppercase. Let me show you. So I can say name.upper. I run that and it turns it into all uppercase. Again, whatever I tell it to do, it'll do. So it could also define an hour.

4:51The idea is that I'm going to write code and ask it to do something. So here I'm asking for the name and then I'll also ask for the hour. I want it as an integer. Again, this is not important, but this is how software 1.0 works. The reason I'm showing you this is because this is what you're sort of doing in English. Not exactly. That'll be clearer when we look at software 3.0. But here I'm doing 1.0 programming. When you do 3.0 programming, there's going to be some parallels. So that's why I want to show you at least one program.

5:24So you get a good idea of some of the little details that go along with it. You don't have to remember this or even fully understand what an integer is or how programming works. And here I'm just saying if the hour is less than 12. Now here you see this is explicitly telling it a rule. Then the greeting will be good morning because it's before noon. Else, if. And now here we're going to ask a different question. So if the hour is not before 12, then we could ask is it before 18? If so, say good afternoon.

5:56But if it's not before 12, if it's not before 18, then you can simply say good evening and you've covered all your bases. So how does this work? Now all we have to do is print the greeting and the name. So we know the name. It's whatever the user adds. So I'm going to add Jonathan. And then whatever the time is, is going to be based on whatever hour I enter. So let's try to do 11 to get good morning. So I ran this and I got an error. And that's really important to understand about software 1.0. When you make an error, it'll tell you.

6:27Chad GPT, when we're talking about software 3.0, if it doesn't know something, it'll lie to you. It'll guess. And that's called hallucination. That is the biggest difference that I can give you as far as the output between these two versions of software. So now I have to run this because I updated it. And then I'm going to say my name is Jonathan. And the hour, let's say it's 11. So that would be 11 a.m. And then I hit enter. And then now I can run this statement or this area to get the greeting and the name based on the hour.

6:57So my name is Jonathan and the hour is 11. Let's see if it works. Good morning, Jonathan. And it totally works. That's software 1.0. Not super exciting. Maybe a little boring if you're not a technical person. But if you are technical, I'll give you this code so that you can play with it, create your own. You can even go to chat GPT and have it write Python code for you. You can just paste it in here and run it. There's a lot that you can do that way. A lot. So if you like that concept, then take the agentic coding course or the vibe coding course, which is exactly what I just described, more or less.

7:34In the next video, we're going to talk about software 2.0. And we're going to use our friends, the hot dog and the hamburger. See you there.

0:00Welcome back. Now, let's contrast 1.0 rules with 2.0 learning. In software 2.0, you don't handwrite if this, then that. You collect samples. And we're going to use Teachable Machine to explore collecting samples. And the samples that I'm talking about are hamburger and hot dog. We're going to make this fun and super easy because this can be complex, but there's no need for it to be complex because we're just exploring software 2.0 and we're creating or teaching a tiny classifier.

0:38So when I say, what is this? You'll say hamburger. That's classification. If I show you the hot dog, you say hot dog. You're classifying what you see that sample as what you know it to be hamburger or hot dog. And what's fun about this is that we can train it and then we can test it. So we'll do live classification with a hamburger and hot dog. And the idea here, the real takeaway is that 2.0 learns from these examples. And we're talking about weights and what that means.

1:09We have these neural networks, we can call these neurons right now, and they're all interconnected. So each one of these has a weight, which just means how important is that information? And then these weights will just output a prediction, in this case, hamburger. So you show it a picture of a hamburger and then you do that a bunch of times, which we're going to do here with 20 to 50 samples per class, meaning one for hamburger, one for hot dog, and then you can create a prediction. And if that sounds a little bit like magic, well, it kind of is, but so is the human brain.

1:43The way that it works is really magical in that context. But let's demystify this. Let's make it super simple. We want to contrast 1.0 rules like we type it in, ask the name, ask the hour, output the greeting to learning. So now let's jump into Teachable Machine and build our tiny classifier. I should say teach our tiny classifier. All right. So here is Teachable Machine. This is from Google and you can do audio, video, images, which is what we're going to do.

2:17Or you can do audio or even poses. So let's click. Get started. We're going to do an image project. You could do audio or poses. The image and the pose project are very similar. This uses the same idea. This is just looking at a bunch of images in sequence, right? That's what video is. One at a time. Those are images. So let's click on this left one here. Standard image model. And now it wants us to gather samples, make or add some samples here or watch this video how to do it. Definitely watch this video if you want to learn more.

2:48I'm just going to take you right through it. This is going to be hamburger and this is going to be hot dog. So samples means give it images. So I cropped the image. That means that I can hold this up. Let me see right here. And then you can see a clear view of this. I'm going to turn it all around a little magnet, but this is how we're going to do it. And all I have to do is hold this down and it's going to take a bunch of images quickly. So we just need maybe 20 to 50. One more. OK, so that's good enough. And I've done the same thing here.

3:19We're going to add the hot dog. OK, so I'm just going to move it all around and give different images because it's learning little patterns. That's how it learns. All right. So I'm going to hold this down. Try to get the same number. I got two more. I'm going to delete two of these. All right. Now we have samples and then we train the model. But let me put it this way. When we're thinking about software 2.0, there's something called bias and this will translate to 3.0. And that's why sometimes chat GPT and other models give you incorrect information because of bias.

3:53So if you have a ton of images, hamburger, but very few of hot dog, it's going to favor this. It's going to say it's a it's hamburger when it's looking at a hot dog. Right. And that's incorrect information. So depending on its training data, which is a big chunk of the Internet, it could have bias because not all the information is equally represented on the Internet. That's why fairness is really important for AI. So just wanted to give you that background why it makes mistakes.

4:27Bias is a big part of that. That's why it hallucinates. All right. So let's train our model. But if you didn't want to learn more about what's happening here, how we're teaching this classifier, click on this video. For now, I'm just going to click train model. And here you can see that there's a timer and zero to 50. Now it's going pretty quickly, but it's doing it a bunch of times here. You could export the model, but now that it's looked at these images and trained or learned a bunch of times, we're going to look at the correct camera.

4:57And now I'm going to crop this. OK, so now it doesn't know what it's looking for. In fact, I should probably add another class. Let me do that. OK, so I've created a background here. And what I'm going to do is get 50 images of this background and delete one. And we're good to go. Now I'm going to retrain the model because we need to add the background without that background. It's continuously trying to predict one of these two, but it has no training data of the background. That's why it doesn't know. But now you can see that it's a background 100 percent.

5:30But if I look in here, it's like, are you a hot dog or you hamburger? It thinks I'm a hot dog. Well, it's good to know that look more like a hot dog than a hamburger, I guess. But now you can see that it's correctly predicting the background. You can see here 100 percent. Let's try out a hamburger, 100 percent hamburger, even if it looks at the magnet. Well, here we don't have a lot of training data for this angle. So we're so it's not as great. So we're introducing a little bit of noise. But if you look at the angles that we gave a training data on, it's learned this on its own.

6:02How about hot dog? Perfect. Moving around even this way, it's perfect on the hot dog. It has a bias for the hot dog, maybe because it's a cute hot dog. I'm not a hot dog, but I'll take that as a compliment. All right. So let's review what is software 2.0 software 2.0 learns by itself. So we were able to teach a tiny classifier, but really it's doing the learning by itself. All we did is give it these images and say, learn these patterns. And then I want you to be able to make a prediction.

6:35So that's what's happening here. And guess what? When you're talking to chat, GPT or any of these other models, it's predicting the next word. They call them tokens, which are like word chunks. So it doesn't do it by full word all the time. Sometimes it breaks it down into little chunks. So it's just making predictions. So when we say the cat sat on the and you probably would say hat. That's probably what chat GPT would say too. That is the most probable next token, but that's what it's doing.

7:06So instead of predicting hot dog and hamburger is predicting the next word after I sat on, well maybe we don't want to say it that way, but you get the point. We're predicting words, which are also called tokens. So software 2.0 learns on its own from examples. There's training fine tuning, and then there's behavior that comes out. And this is the output, which we said was predictions. All right. So in the next video, we're going to talk about software 3.0, and that's what we all know as generative AI or chatbots like chat GPT.

7:43See you there.

0:00Welcome back. In this video, we're going to explore the concept of plain language programming. And one of the innovators in the AI space is Andrej Karpathy, and that is the person that I'm borrowing the term software 1.0, 2.0, and 3.0 from. And a cool quote from Andrej Karpathy is, the hottest new programming language is English. Here's why. You can think of a prompt is a little program that you run at runtime, meaning you type it as a prompt and press enter. It's not code, it's English. Runtime is the moment of execution. For example, this is code, but I need to push this play button or run it. And this would be considered runtime. So then it outputs this hello world. And much like programming, this is the runtime.

0:55When you're talking about chat GPT. So you can think of prompts as runtime instructions without any code, but it's important to note that you're not changing the weights, meaning you're not changing the program that created this chat GPT, which is based on software 2.0. What you're doing is changing the behavior by giving it a context. You're steering the runtime to get an output or a prediction or a behavior. So you can think of it as constraints plus an example equals a pattern, meaning you can keep the facts in the excerpts or an example to teach the model, the style and the format that you want. So the goal here is shorter, steadier and paste ready outputs. You want to get the output the first time.

1:46Some people just prompt in hope and that's not the way to go. And you don't want to talk to it like a human. That's also not the way to go. You really want to think of prompts as plain language programming. First, let's talk about LLMs. These stand for large language models like chat GPT and others such as grok, Gemini or clod. And what they're doing is that they're picking the next token from a probability distribution. What does that mean?

2:17So token means word or it could be a word chunk. For example, R E L A Y. These could be two. But what we're saying is relay. So it could have two tokens to represent one word and it predicts just the token. So the next token from a probability distribution. So we could have the word or the token I, and then we could have a series of choices like I love or I ran or I met. And each one of these are going to have some kind of a percentage associated with them. And it usually picks the highest one. So there's concept of temperature, which we'll explore later. But for now, to give you an idea, the higher the temperature, the more variety, the lower the temperature, the more stability. Also, on top of variety, you'll get some pretty wild answers. It kind of gets more creative wild. And here you get a more plain and stable output, less creative and less wild. But when I say that consistency equals reducing the degrees of freedom, that means that if your prompt is vague, the model gets to guess and you don't want it to guess because it's probably not going to be what you're thinking. So the less freedom equals a steadier output, or we

3:37could say more consistent. So we want to reduce the guessing or the degrees of freedom. You want to specify shape and you want to use techniques like one or a few shot examples. And this is going to steady that voice. These are all techniques that we're going to explore in this course, but I'm just giving you sort of a preview of what the goal is. We want really good outputs and there's different things that you can do. Essentially, we want to reduce the degree of freedom, meaning we don't want it to guess. We want it to know exactly what we want. That's how it can give us what we want. In practice, this means you control the behavior by tightening the program. So here's where we're going. We're programming with English and that means using techniques like CRE. We want to give it a clear context, a clear role and clear expectation.

4:31Plus shots. These mean examples, no example, one example, or a few examples. And we can also add facts, which we can call excerpts or examples, which are going to relay the style in the format that we're looking for. So we'll start simple using CRE or context role and expectation. And then we'll dive into a schema, length cap, tone macros, safety boundaries for paste ready outputs.

5:02We're just going to increase the complexity. And when you do this, this is advanced prompt engineering. The goal of this course is to take you from the very beginning from AI fundamentals to understanding what software 3.0 is, and then give you the tools that you need a prompt toolkit so that you can reuse them for yourself or for your team. This is going to dramatically improve the quality of your work and the quality of the outputs of your models. All right. So let's talk about what a naive prompt is. Just to clarify, it's not a context role expectation. It's really just talking to a human, right? Something very casual. Should I update to iOS 26? This is the part of the problem. These companies are suggesting that we talk to these models like humans, but that's why prompt engineering really frames this as programming and gives you an advantage while everybody else is talking to it like a human, you can talk to it like a programmer, or at least with the foundational knowledge of programming and your outputs are going to be on fire. I'll show you why. So we're done with the video, but I want to show you how to do a naive prompt. Let's say that you need to summarize something. If you just say, summarize this, and you

6:20have some kind of a message, this is a naive prompt because you're not thinking about the context. You're not thinking about what the role is or expectation. So how is the model going to know in this case, it's at GPT-5, I believe, how is it going to know what you want? So the challenge is about doing a regular summary, so a naive prompt, and then strategizing. How could you give it more information to get the output that you exactly want? So the challenge is going to give you how the prompt should look after it gets summarized. So I'll give you a context or a scenario or some text data that needs summarization and the expected output. And without using any special skills, see if you can invent a way to talk to it. Maybe imagine that you're a programmer and you want to be very specific to see if you can get the exact output that we're looking for. And in the following skills, we're going to iteratively build on all of the techniques all the way to the very end of this course, where you'll have a prompt toolkit that you can reuse. You can just copy and paste so that you don't have to think like a programmer and reinvent the wheel every time that you're going to talk to these models. All right, so up next is a challenge. And until next time,

7:37I hope this has been informative. I'd like to thank you for viewing.

0:00Welcome to the challenge section. Here, we're going to use ChatGPT. Let's assume that you've never used ChatGPT. You could use another model if you like, but it would probably be easier if you use ChatGPT, which you can find by navigating to chatgpt.com. Let me make this a little bit bigger. All right, your task is to recreate a target output as close as possible to the example that I've given inside of the challenge. So just look at that example. And what you're going to do is just say, summarize this.

0:31And so anything that you type in here is a prompt. So I'm going to say, summarize this. And then I'm going to add this example. And this is what we're going to summarize. So let me run this. All right, so we get something. And this is something that just popped up that we're going to talk about in the next skill. It's really important to understand the terms and the privacy, and definitely don't share private or sensitive information in these models at any time. We'll talk more about that in the next skill. So I'm going to close this. And I haven't logged in.

1:02So this is very public. So all of this information is going to be stored and reviewed by OpenAI. But this is OK because you're just typing this in. And now your challenge is to get it to look like the solution, which is just below. And it has emojis and bullets. And so just try to type something here, create your own prompt that gets it to be closer. Because this does not look like the end example. And the idea here is that you're flexing your prompting muscles, right?

1:33This is the very beginning of our journey. You're going to try to get an output to be what you want it to be. When you just say summarize this, that's called a naive prompt. Well, you can see that the output is not even close to the final output that we're aiming to create. So try to do it. And as we navigate this course, I'm going to give you more and more techniques to help you create awesome prompts. So try to have some fun and enjoy this process. Be careful not to add any sensitive information into the chat.

2:04And if you get a message saying that you've run out of opportunities to use this, you can sign up for free. Or you can sign up for a paid account if you want to continue to use this. But if you're taking a prompt engineering course, you probably have used ChatGPT before. All right, good luck. And I'll see you in the solution video.

0:00Welcome back. So here is the example text that needs the summarization. So we grab this, copy it, go to chat GPT, and we paste it there. So we'll try the naive prompt first. Summarize this. That's a naive prompt. And let's see what we get. Okay, so we get this basically two sentence summary. But let's say that we want it to be for Slack, and we want it to look something like this. So how would you go about supplying a prompt that would look like this? And here is my solution, where I describe it in much more detail. So here I'm just saying summarize this. But here I'm saying summarize the following text into a short Slack friendly update. Use five to six bullets max.

0:43Each bullet should follow this format. Then I go in to describe the emojis. Then we have a bold label, a short casual description of each moment. Then above the bullets, we add a title, something like team or project update. And then I've supplied the text. And then we get something that looks pretty much identical. The only difference is the title is slightly different. It says pixel and beam update. And here it says pixel and beam launch prep. But that's close enough. All right. So that's it for the challenge. I hope you enjoyed it. And I will see you in the next skill. And until then, I hope this has been informative. I'd like to thank you for viewing.