Identify the Main Types of AI

0:00Hello and welcome to the first skill in the AI Productivity for Professionals course. My name is Jonathan Barrios and I'm excited that you're here. This first skill marks the starting point for learning how to use AI tools like ChatGPT, Gemini, Copilot, and NotebookLM to work smarter, faster, and safer. In this course, you'll learn to draft and refine documents, messages, and data-driven insights with AI.

0:31Turn ideas into polished deliverables using Google and Microsoft's ecosystem. And most importantly, apply prompt engineering to steer the AI reliably, not just experiment with it. I want to show you that this course is part of an AI series of mini courses. And we are here. And while I did mention Microsoft Copilot, there's a whole mini course on that. Again, it's a mini course, so it's not a complete course on Microsoft Copilot, but it will get you started with understanding AI, prompt engineering, and how to use the Microsoft ecosystem leveraging AI essentials.

1:13In this course, we're going to explore ChatGPT, Google Gemini, and NotebookLM. But again, it's also a mini course on AI productivity. And most of these mini courses include a first skill on what is AI, because it's paramount to understand what AI is and how it works behind the scenes. Then we get into prompt engineering, but it's a mini crash course on prompt engineering. So I highly recommend taking this mini course on AI prompt engineering to get the most out of your AI models.

1:50Again, here in the AI Productivity for Professionals, we're just scratching the surface. And if you're an executive or leader or interested in launching your own AI product, Artificial Intelligence for Executives and Leaders takes you from the idea stage to the deployment stage on AI best practices. And for those of you who are interested in programming, I suggest this one first. And then if you have no programming background and want to explore vibe coding, which is a new trend that is taking the internet by storm, which simply means the AI codes for you.

2:26But you definitely need to know a little bit more than just using AI, for example, security. And we have you covered in this course. However, if you already have a programming background, then a good next progression would be AI agent decoding, where you use AI agents to help you program even faster. But if you already have a programming background, you don't need to take this one. You can just skip right to AI agent decoding. And finally, if you're trying to deploy your product or you're part of a team and want to understand AI compliance, privacy and copyright, we have one here for developers, which is a more technical approach.

3:05And this one for non-technical audience. So the goal here is to get you up and running with AI in all of these different contexts. Again, if you find that you want to go deeper in any one of these, just tell us in the comments. And that is precisely the data that we need so we can make the courses that you are most interested in. All right. So now what is in scope or included in this course? First up, we need to identify the differences between the main types of AI because AI isn't just one thing.

3:39And we also need to understand the basic prompt engineering for AI productivity. These two are foundational concepts to build a mental model. And then we'll leverage AI tools using what we learned in prompt engineering to give us the optimal productivity using AI. So now what is not included in this course or out of scope? We're not learning about how to code. Even though we're going to talk about it briefly, I guarantee you that it's going to be fun and non-technical.

4:13The idea here is just to have a good understanding of how AI works in the background and what is not AI and no tutorials on how to build AI chatbots. If you want to learn more about AI chatbots, definitely check out the AI agentic coding course. Furthermore, this is a vendor agnostic focus, meaning there's no specific vendor focus. While we do talk about chat GPT and Gemini, this can be applied to almost all AI models, even Microsoft Copilot.

4:46And really the takeaway is that this is about general AI productivity for professionals. And a little bit about me. My name is Jonathan Barrios, and I teach data science, machine learning, and deep learning. I like to call this AI data science, which is the combination of AI engineering and data science. I've worked with AI and built SaaS websites, AI applications, and streaming platforms. And I've been teaching for quite some time at top platforms such as Treehouse, Thinkful, and Chag.

5:20And now I'm excited to be part of the CBT Nuggets team. You can definitely find me on LinkedIn at jonathan-barrios-ai or my website at jonathanbarrios.com. And finally here at AI underscore data underscore science on x.com. And a real quick note on x.com, some people love it, some people hate it, but I don't really use social media. So you might be wondering, well, then why are you on x? And here's why.

5:51I think social media is kind of a waste of time, but what I use it for is to keep up with the speed of advancement. It's a rapidly expanding field, and this is better than a newsletter. The entire AI community is on x, and you have access to Andrej Karpathy and many others who are leading in the field, posting directly on x. So if you follow just these people, and including myself, you're going to hear about AI and AI data science, as I like to say.

6:23You're going to get a feed full of AI developments and not all of that noise. All right, enough about me. Let's talk about this course and the first skill. Here, we're going to identify the main types of AI. Before we dive into any prompts or any projects, we need to understand what AI actually is. Not the buzzword version, but the functional one. You'll see how software itself has evolved. And to make this super accessible, we're going to talk about three different kinds of software, and I will make them very easy to understand.

7:00And furthermore, it's going to be directly applicable to prompt engineering and AI productivity for professionals. We definitely don't want to talk about all of the nuances of AI, which I personally love to do, but it's not going to help you be more productive. We're going to distill it into a very simple mental bottle that you can take with you from now into the future, because AI is not going anywhere. The sooner you build this mental model, the sooner you'll be able to navigate AI much better, and then we'll get into prompt engineering.

7:35And best of all, by the end of this skill, you'll understand the landscape and the mindset and the foundation of every AI workflow we'll build together. All right, so what are we going to cover in this skill? Number one, what is AI? Really? Before we get into prompts, we're building that mental model or that mental map. You'll see how AI evolved from simple rules to programs that learn from data. And to study that evolution, we'll look at it through the lens of software 1.0, 2.0, and 3.0.

8:11These are three types of software that are very easy to understand and will give you the intuition needed for the next skill, which is on prompt engineering. And then why modern AI can be so confident and also so wrong. This is probably one of the more important concepts of this entire course, and it's the foundation for improving your productivity. And number four, we'll lay the foundation for prompt engineering, and we'll do that with a challenge at the very end.

8:46So this is going to be a really fun skill. We're going to build an advanced AI model that can tell the difference between a hot dog and a hamburger. And to do that, there's zero code involved. It's just a simple website. And I have my two friends right here, hot dog and hamburger that are going to help us do this. It's going to be a lot of fun. And if you don't have any hamburger and hot dog toys, don't worry, you can just use the number one or number two as your classes. And this is really about giving you that foundation for your mental model before we get into prompt engineering.

9:21All right. On that note, I will see you in the first video on what is a I see you there.

0:00Before we start learning about prompt engineering or using tools like Gemini, Copilot, and even ChatGPT, we need to understand what's really going on under the hood. If you know how AI thinks and learns, you'll instantly get better results. Not because you memorize different prompts or you have a deep understanding of AI, but because you understand how to talk to it on its own terms. Many people will talk to AI like it's a human. And when you do that, it confuses the AI and then it starts to guess.

0:38And that's where it makes things up. And it does so very confidently. That's why we start here with what is AI. It's the foundation that we need for writing proposals and docs to analyzing data in Google Sheets or Microsoft Excel. And more importantly, AI isn't one thing. If you thought that AI was ChatGPT, it is, but that's not what AI is entirely. It's not all chatbots. AI is really an umbrella term.

1:08So let's check it out. When we say AI, we're really talking about this umbrella term, artificial intelligence. And that umbrella of different techniques is how the computer learns patterns and makes decisions, and sometimes even creates new content. That would be generative AI, but Gen AI is just one slice. At the simplest level, AI is software that improves with experience instead of relying on human written rules. For example, when we look at machine learning, this is one type of AI that finds patterns in data to make predictions like detecting spam emails or recommending products or forecasting sales.

1:54The key word here is learns. It learns on its own and it learns from data. We're not telling it what to do, how to think that's traditional programming. And when we look at deep learning, this is a subset of machine learning that uses neural networks. Neural networks may sound complicated, but we all have neurons in our brains. And when they're connected in a network, those are neural networks. And that's how humans think. That's how we process information.

2:27So it's very similar to how humans operate. In fact, it's software modeled after the brain. So instead of using human neurons, we use something called an artificial neuron. And the way I like to think about it is like Gandalf, thou shall not pass unless the data is important. And that's what a neuron does. It only allows important information to go through. And if it's not important, thou shall not pass. And when you have a giant network of these, that's how deep learning learns from the data.

3:01It may not make total sense right now, but when we train our hot dog and our hamburger models, it will. And we're not going to use any code. And in fact, you're going to build your own classifier. And I'm going to explain precisely how it works. And then finally, the newest layer of AI generative AI, also known as gen AI for short powers tools like chat, GPT, Gemini and co-pilot here. We can create language or programming code or media like images or videos all on demand. It's pretty exciting.

3:37And when you use Gemini or co-pilot, you're working with deep learning models that have been fine-tuned to understand and generate language. Those are called large language models or LLMs for short large, because they use a large amount of data language because, well, that's what they're using. And what are they models? So a large language model is what powers things like chat, GPT.

4:08And what's important to note is that AI doesn't know things like a person does. It predicts what is likely next based on patterns and it's training data. And that's why, how we ask a question is so important. We need to ask the right question, set expectations and even give context. And that's what we call prompt engineering. And that's in the next skill. Okay. AI is an umbrella term for machine learning, deep learning, and generative AI.

4:42They generally learn from data in different ways, which we're going to explore, but you don't really need to memorize the different learning styles, such as supervised self-supervised or unsupervised, or even reinforcement learning. These are just the learning styles in case you want to learn more. And the AI umbrella really spans all of these rules, search machine learning, deep learning, and gen AI. But we're just focusing on the top three machine learning, deep learning, and generative AI. That's all we need for our mental model.

5:17And if you're thinking about modalities, well, vision, that's what cars use to drive themselves speech. That's how chat GPT talks to us and other models that use speech NLP. This just means natural language processing. That's what powers generative AI chatbots recommendations. You might see this on YouTube and robotics uses a combination of these three. Let's explore how, when you look at these AI use cases, you might be overwhelmed saying, well, how do I know what AI does?

5:51What, but you can think of it in really simple terms. For example, when I explain what I do for a living, I say that I teach the computer to read, to see, and to speak, but how does that actually happen? Well, I use different kinds of AI like machine learning, deep learning, and generative AI, but that's all we really need to think about. Is it seeing, is it using language to communicate like text, or is it doing something else? For instance, when you're thinking about facial recognition, this is often deep learning because it's great at learning from the data.

6:28Meaning if you give it a bunch of pictures with labels and gets really good at identifying them and making predictions. So you could say that facial recognition is a form of deep learning, but you could also say that it's computer vision, which autonomous vehicles use because they're identifying patterns. So here it sees a tree, a car, a person assigned here. It sees an older person, a younger person, a person with Brown hair. They're wearing orange shirts and so on.

6:58These are all instances of computer vision, which includes facial recognition. But how about fraud detection? This is often machine learning. Machine learning uses algorithms to make predictions and learns from the data by using algorithms. So in this case, fraud detection, it looks at a bunch of data and it says, well, the values are from 50 to 100, like 99% of the time. But if you see a value that's 10,000, well, that's going to be a red flag and that could be fraud detection or some kind of an outlier. And algorithms are great for that.

7:36But when you're looking at all of these patterns, deep learning is better for that because it's software modeled after the brain. Well, how about robotics? That could be a combination of deep learning and machine learning, but it could also be gen AI because it uses deep learning to see, and maybe it speaks using generative AI, and maybe it's calculating some kind of an outlier when it's moving its robotic motors. So AI can be combined. For example, here we could use deep learning and gen AI.

8:10If we're looking at an image of text, turning that into characters and then creating new variations on those characters. So that would be deep learning and gen AI. And again, it's not really important to know what use case uses, what it's really to understand that AI means different kinds of things. Generally it learns from data in different ways. In the next video, we're going to really dial this down and simplify it by looking at the different types of software, 1.0, 2.0, and 3.0.

8:44See you there.

0:00To really understand how AI changed the way we work, let's step back and take a look how software itself evolved. The model of thinking about software as 1.0, 2.0, and 3.0 comes from Andrej Karpathy, who's one of the leading figures in the AI field right now. They helped start OpenAI, and also played a huge role in Tesla self-driving vehicles. And what I really like about Andrej Karpathy's framing is that it gives us a clear picture for everything we'll do in this course, from writing prompts to generating full documents and presentations.

0:40Here's a story in three simple steps. When we were talking about software 1.0, we told the computer exactly what to do, step by step. Every condition, every formula, every loop. If you wanted to change how it behaved, you had to change the code. So the code changes the behavior, and these are rules that we coded by hand. So this is traditional programming, also known as coding. The way that I like to explain software 1.0, or traditional programming for that matter, is if X, then Y.

1:16So you can tell the computer, if the number is above 10, then do this, Y. So if X, then Y. If some condition, then do some action. This is logic that is exact and reliable, but it's also rigid. It's not like software 2.0 and 3.0. So that being said, let's explore software 2.0. Instead of coding the behavior manually, we feed the system data and train it to find the patterns by itself.

1:49So here, the AI learns from data, and we have machine learning and deep learning, which are both part of software 2.0. And the rules are written in weights. When you think about neurons and neural networks, we have all of these individual neurons in a brain, but here, we can think of it as a computer. All of these individual neurons get assigned a weight. That means, how important is this piece of data? And that's how it learns.

2:19It just says, oh, that's not important, this is important. And when you combine all of those different weights, it doesn't need traditional programming or rules. It just predicts, it learns from the data. You could also say that it learns the rules from the data. Unlike software 1.0, when we're coding the behavior manually, here, we're just giving it data and training it so that it learns. And that's machine learning and deep learning. The difference between machine learning and deep learning, again, deep learning is software modeled after the brain, and machine learning uses statistical learning or some kind of an algorithm or statistics.

2:58But the end goal is the same. You see this in things like recommendation engines or fraud detection or email spam filters. And here's this training thing. What is that about? You're gonna find that out very soon when we get into the hamburger hotdog model that we're gonna build without any code, and it's actually quite fun. And then fine-tuning is how you create a specialized model like hamburger hotdog. We could fine-tune a model to distinguish between those two items. And if you wanna change the behavior, well, you have to retrain it with new data or fine-tune it with new data.

3:34It's not code, that's the takeaway. All right, so now how about software 3.0? This is Gen AI. So now we've covered all of the different types of AI, but what's so special about software 3.0 or Gen AI? Here, we guide the behavior with plain language. The rules are now prompts, and this is why we need prompt engineering, because talking to the AI by typing is much more powerful than it seems.

4:05It's really a kind of programming. Here, we use code to program. Here, the model learns by itself. It doesn't even need us. Sure, we do write some initial code and give it the data, but beyond that, it creates its own rules. It learns the rules. But here, the rules are really the prompts that we give it. So now everybody has the power to do some kind of programming. So if you wanna steer that model and change the behavior, you do that at runtime.

4:37That means whenever you type it into a chatbot and hit Enter, you're steering that AI model and changing its behavior. So it's really like a type of programming, and that's what I'm getting at. The sooner you can start thinking about generative AI as a form of programming, the better. Andrej Karpathy himself said, "'English is the hottest new programming language," which is pretty bold. Why would English be a programming language?

5:07How's that even possible? We have programming languages such as Python, which are very human-readable and easy to learn, but it's still a programming language. There are data types, all kinds of symbols that you need to understand how they work in order to build some kind of a software application. But English? And that's the cool part. Yes, not just English, but plain language, because AI works in many different languages. So here, for software 3.0, we don't code rules or train the data directly.

5:42We simply steer the powerful pre-trained models using plain language. How do you do that? You describe what you want, who it's for, and how it should sound. That's more or less prompt engineering, which we'll get into in the next skill. So just think about chat GPT. Every time you type a prompt into chat GPT, or even Gemini or Copilot, you're not programming in Python, you're programming in English. In essence, plain language.

6:12And that's why we start with the mental models before we write any prompts. When you realize that the words are a type of code or a new kind of code, you start to see why clear, structured communication is the core skill of modern productivity. All right, so we learned that prompting can change the behavior of these models, and you can change the weights by fine-tuning or training. What does all of that mean? You're about to find out.

6:43So what are the actual levers or the tools that we use to program in plain language? That's gonna be CRE, shots, constraints, retrieved snippets, or more simply said, facts. These are all components of prompt engineering. CRE just means context, role, and expectation. Shots are examples. Constraints are less than 90 words, for example. And then we give it facts. This helps it stay on point and not guess.

7:16All right, enough of the theory. In the next video, we're going to check out Google Colab. You don't need to use this yourself, just follow along, and I'm gonna show you how traditional programming works. See you there.

0:00Welcome back. In this video, let's make this idea of software 1.0 real, and we'll use something that every professional understands. Excel formulas and email rules. You either know about Excel formulas or you know about email rules, like sending something to spam or even just deleting it. In software 1.0, everything the computer does comes from instructions that you explicitly define. And we're going to do that above.

0:31This is where you add the code. What we're going to do is tell the computer what to do line by line. And each one of these are called code cells. This is just to let you know what we're going to do and how it works. Let's say that we want to think about Excel. In that case, you might write a formula that says, if this is very common in Excel, and then you would use parentheses. And inside of the parentheses, you would write some sort of condition. So you could say something like sales. If that value is greater than 1000, then do X.

1:05If not do Y. So what are X and Y? We can say bonus and it would classify that as a bonus and it would change the text to bonus. So instead of showing you a value, it's going to change it to that bonus because it's above 1000. However, if it's not, then it's going to say no bonus. If X, then Y else Z. So you can have multiple cases, but the takeaway here is that it's a rule. In this case, if this, then that, then that, or in Gmail or Outlook, you might create a rule that says if the subject contains invoice, move to the finance folder. It's the same thing. It's a rule, but instead of Excel, we're in some kind of a mail application.

1:52Every outcome depends on manual logic and that's not how AI works. And we can do this when we're programming. Let's say we take sales and we give it a value of 5,000 or let's say 50,000 are really big number. And then I'm going to just say if sales is greater than 10,000, I want you to do something. But in Python, it's a little bit different than an Excel formula. So you simply do this and you type in bonus.

2:22So I'm going to run this cell and it connects to the cloud and then immediately gives us an answer bonus. But we could take this a step further. We can say else print no bonus. Now we have the same exact thing that we have in Excel. So here it's above 10,000. So it's always going to print bonus. If this, then that, and it's simple as that. However, if I change this to 100 and then we run it again, you get no bonus. So to change the behavior, you change the code.

2:55So let's say that you're looking for it to be equal. You run this, no bonus, or you can say not equal in this case. So we're changing the code. So it's not equal to the bonus, but we'd say 1,000 or 10,000 in this case. And it says bonus. Maybe it might make sense to say something like bonus amount. What I'm doing is changing the code, changing the behavior. And that's it. This is precise, but limited. The system can't generalize. It only knows what we're telling it here.

3:27If we needed to do something else, we need to actually change the code that's located here. Same thing with Excel, same thing with a Gmail rule. And this is where AI steps in. Instead of hard coding, every rule AI learns patterns. And that shifts from your logic to the system learns the logic. And this is what brings us from software 1.0 to software 2.0 and 3.0. Just before we get there, just remember this mental image in software 1.0, you have to think of every scenario in advance and software 2.0 and 3.0, the models learn from the data.

4:09And more importantly than 3.0, you describe the goal and the AI figures out how to get there. So that means that you don't need to learn how to code. Instead, you need to learn how to prompt. And in the next video, we're going to demystify how models learn from data. That way you understand how generative AI works, and that's going to give you the secret sauce for prompt engineering. And that way you can leverage this, not just for productivity, but for any AI application moving forward.

0:01In the last video, we explored traditional software, also known as software 1.0. And that's where we write the rules. Rules by hand means that the code generates the behavior. And if you want to change the behavior, then you need to edit the code. So the code just means explicit rules and there's no learning. That's the important part. And in the demo, we could have created a greeting based on hour, but we chose Excel and Gmail. And now that we've seen how software 1.0 works, where we use explicit rules and every scenario must be hard-coded, let's move into software 2.0.

0:37This is where the system learns the rules. And to do that, we're going to build a tiny classifier. And by build, I mean teach. And we'll use Teachable Machine from Google to do just that. This is a wonderful application that's in a browser and you don't need any kind of coding experience at all. All you need to do is just have a webcam and that's it. And furthermore, you don't even need to do this. You can just watch me do it and you'll understand how the AI learns.

1:07Not at a deep level, of course. You're not programming and building this out, writing code, which is what Teachable Machine abstracts. And that way, we can focus on how these models train and then make predictions. And that's exactly what ChatGPT does. Okay, so the rules are in these weights. But the secret sauce is when you train the model or fine-tune the model, these are two ways that the models learn the patterns and that's what creates the behavior.

1:37To do this, we're going to collect 20 to 50 samples. In this case, that could be 20 to 50 images for hamburger and 20 to 50 images for hot dog. But if you don't have those toys lying around, then you can use your hand. With a number 1 or a number 2. And then once you've created the data, then you train and then the model learns from those images. And then you can preview it and do live classification. What does that mean?

2:07After you train the model, you show it either a hamburger or a hot dog or in your case, 1 or 2. And it's going to tell you if it's a 1 or a 2 or a hot dog and a hamburger. And it's going to do so using a probability. It'll say 100% hot dog or 10% hot dog or 90% hamburger and so on. And that's an important detail because the AI doesn't always know 100% what something is. And it has to make a choice and that's why sometimes it's wrong.

2:38So what we're saying is that instead of writing a list of conditions like if this, then that, we give the computer examples. It studies the data, looks for patterns, and builds its own internal logic. And that's what we call a model. So now let's make that concrete and fun in a simple demo using Teachable Machine. Again, you don't have to do this. But if you are curious and you want to follow along or you want to play with this on your own, you can go to teachablemachine.withgoogle.com.

3:13You can use audio. You can use video. You can use poses. You can use images. Let's get started. The first choice we need to make is whether we're working with images, audio, or poses. But in reality, they're all images. Here you can see that the audio has been converted into some kind of a visual representation of sound. And here in the poses, these are just individual images stacked one after the other. The images, we're just using single images one at a time.

3:45But they're really all image projects, which means we're doing computer vision of some kind. All right. So now click on the standard image model. And here we need to gather our samples. So it says make or add some samples here or watch this video on how to do it. So definitely click on this to learn more. But I'm just going to show you how I do this. First, I'm going to name this hot dog. And I'm going to name this hamburger. Next, we need to click on the webcam. Okay. So now I'm going to click on crop and make this smaller.

4:16Move it over here. Try to get out of the way. And then click on crop. Now you can just see this area. And I'm going to get the hot dog and then hold it up there. And then I'll move this around. But I need to hold this down and record these images. So let's aim for 100. Perfect. 100 images of the hot dog. Now it's time for hamburger. Same thing. Click on crop. Move this to the top right to get it out of the way. And say I'm done cropping. And then here we have the hamburger.

4:46I'm going to do the same exact thing. I'm going to hold this down and move it around to get different images, even the back. Perfect. We have 100 images of hamburger. Let's close this. But you might be asking, well, what happens if you only have 10 of hot dog and 100 of hamburger? And that's called bias. We favor hamburger 10 to 1 because it has 10 times more samples. And that's why fairness is so important. You need to have equally distributed representations of data.

5:19So generative AI can be really tricky. Now we train the model. Now that you have two classes, you can train your model here or add more classes, which we're going to do. But first, let's try to see why we need more classes. Click train model. And then it does this quite a few times really, really, really quickly. You can see that it does it 50 times. These are 50 training epochs. And then here it wants to preview it. But I need to get out of the way.

5:49Let me crop this and try to get out of the way because now it thinks that I'm a hamburger. Now it thinks I'm a hot dog, right? It's super confused. So let's click on crop. And there we go. I'll get out of the way. And now it's saying that the background is hot dog. And that's why we need to add another class down here for the background. But before we do, let's test it out. 100% hamburger. Even if I do this, it's still pretty good. Look at that. Now let's do hot dog. 100% hot dog.

6:19Even the back. Even in this way. Any which way that you do it, it's seeing that this is definitely a hot dog. OK, so now let's create one more class. And let's go over here to webcam. I'm going to do the same thing. Crop. Get out of the way. Move this over here. Done cropping. And I'm just going to hold this for 100 images so that it has training image or training data. But we can just delete these two here like this. And now we have equal amounts of samples. This is really important. And here I'm going to say background.

6:50All right. Let's close this. And now to change the behavior, you have to retrain the model. That's what we were saying. So let's do that. So now I'm training the model again, this time with three classes. Hot dog, hamburger, and background. Now that I'm moved out of the way, hopefully I don't have to do that cropping again. And I don't. You can see that the background is 100% accurate. If I stick the number two up, it gets totally confused. It's like, what is this? A hamburger?

7:20A hot dog? I can't tell. Oh my gosh. If I do this, then maybe it's more of a hamburger. At that point, it just doesn't know. But if you do this, wow. That's a hamburger. 100%. If you do this, it's definitely a hot dog. If you do this, it's a hot dog. Nope. That's not a hot dog. So it just hallucinated. And that's one of the problems with generative AIs. If you don't have the right data, you need the data to be perfect for your task.

7:50Or it might make stuff up. And that's why we're going to get into prompt engineering in the next skill. But first, let's check out software 3.0. See you there.

0:00Welcome back. Hopefully you have a much better understanding of what AI is and what the difference is between traditional programming and models that learn from data like classifying hamburger or hot dog, and some of the drawbacks such as bias and not having good representation of each class, or more importantly, no representation of, for example, me, it thought that I was a hot dog. So these are important clues.

0:30And now let's talk about software 3.0, which is really the main focus of this skill. Now we're stepping into software 3.0, the world where most of your modern tools live here. We're not coding rules like 1.0 or even training models like we just did in software 2.0. We are steering intelligent systems in real time using language. I like to say that software 3.0 is prompting as plain language programming.

1:05And that's why I really like thinking of prompts and Gen AI as software 3.0. When you use chat GPT, Gemini or Microsoft Copilot, you're not retraining the model. You're conditioning it in the moment. It's incredibly exciting and powerful. Every prompt you write acts like a short program in English. So really they're rules in prompts, which are plain language. And what does that do?

1:37You're steering the behavior. If you want to change the behavior, change the prompt. What we're doing is setting context, assigning the role and defining what a good output looks like. We'll get into that in the next skill with C R E. Context role and expectation. When you do that, it's much like software 1.0. You're saying context equals, and then you define what the context is or role equals. And then you define the role or expectation equals, and then you define it.

2:12But instead of using numbers or data types or some kind of programming language syntax, you're using plain language. So that's what you add here. What is the context? This prompt, what is the role? What is the expectation? You do this and you're going to really steer that behavior. You're going to get really, really good at it. So prompts are runtime instructions, meaning no code, and we're not changing the weights. That's what software 2.0 does.

2:42But what we are doing is conditioning the behavior using context. So we're steering via constraints and examples. Examples can be thought of as patterns and we keep the facts as excerpts where each example teaches this style in the format. Again, this is all prompt engineering. The goal here is shorter, steadier and paste ready outputs. If you've used chat GPT and you've had to talk to it over and over and over, or it says stuff that's really wrong and confident, or it just says really encouraging things over and over. You're doing great.

3:20When you know that you're not, then you're going to love prompt engineering. So let's try to come up with an example together. Let's say you want Gemini to draft an email for your coaching business. And we are going to use the example of Thrive 365, which is a business that we're going to build. It's an exercise and nutrition startup. So we'll keep using this example. So here, how would you write an email to the new clients of Thrive 365? You could say, write an email to new clients, but the output might not be great.

3:54But if you use structured clear prompts, which we call CRE, then you might say, well, this is for Thrive 365, a hybrid fitness and nutrition program. And how about role here? You might say act as a professional coach who writes friendly and confident emails. How about expectation here? You might write create a short welcome email under 120 words that thanks them for signing up and explains the next steps.

4:27When you do that, you're doing CRE, which is prompt engineering. Now the outputs fit your purpose, your brand voice and your audience. You didn't retrain the models like you would in software 2.0. You programmed the AI with words. That's the key shift from 2.0 to 3.0. In 2.0, we shape the behavior by training it with data. In 3.0, we shape the behavior with language.

4:57And this is the foundation for everything else we're going to do in this course from writing emails in Gmail to documents in Google docs, to slide decks in Google slides, and even research in notebook LM. But how do these generative AI models, also known as large language models or LLMs produce this output? As we saw with the hot dog and hamburger, they use probabilities. It's never 100% sure. I mean, it is when we were looking at the hot dog and hamburger, but the idea is that it's anywhere from zero to 100.

5:33It's not always zero and it's not always 100, meaning it's not a true and false situation. There's a wide range of possibilities. That's why it uses probabilities to make the next token. So these large language model picks the next token full stop. What is a token? So a token is a numeric representation of text, and they're not always one word for one token.

6:03There can be multiple tokens from multiple words. So I like to call them word chunks. So why are we using word chunks? Well, that's what the computers prefer. They like numbers. So we could have a word like reproduce. And since computers are so efficient, they might say, okay, re and produce. Two tokens. That way they can reuse them quickly and they're not going to be in text. They're going to be numbers. We'll get into that a little bit later. So they picked the next token from a probability distribution. And so what does that mean? Well, you could say the cat sat on the, and then you would have the top three picks.

6:39The one that has the highest probability will be picked. So it'll probably be the cat set on the hat instead of the cat set on the Lexus. One is going to be way more probable based on all of the training data on the internet that it used. Another key concept here that is super important is temperature. The higher the temperature, the more variety that you're going to get from your model. The lower the temperature, the more stability, but also could be a little bit more boring. So if you want more creativity, crank up the heat, turn that temperature up, but you're going to risk getting some weird and maybe incorrect output.

7:16So you might want to find a nice balance. Normally we cannot set this, but sometimes you can, this is just to give you an idea of how the output is produced. The temperature really matters. Different models will have different temperature settings. And finally, consistency is the same thing as reducing the degrees of freedom, meaning the number of choices. So if you give the model a specific shape, like I want labels or count or format, you're reducing the degrees of freedom, which gives you more consistency.

7:50That's really what prompt engineering is about. You can add one or a few shots. Shots are simply examples, and this is going to help you get a better output or steady the voice. So imagine a forecast that says that there's a 70% chance of rain. The model can't know for sure. It's just estimating the probability from the data. So those are called forecasting models and AI is often used for these models and large language models work the same way.

8:21They sample from a probability distribution of what's most likely to come next. What's the most likely next token. This also explains why your prop structure matters so much. When you give the model a clear framework, like return of three bullets, status change and action, you're narrowing the probability space. You're reducing the degrees of freedom, meaning you're reducing the choices that it can make.

8:51And that helps the consistency or improve the model output. That's how you turn creative text generation to consistent professional output. So where are we going with all of this? Here's the goal. We're going to become programmers, but we're going to use English. So you can think of talking as a form of programming, but we're going to change it so that it's a little bit more effective with AI. So programming with English for AI, that's who we're talking to generally large language models.

9:22So we're going to use CRE to pull that off because AI likes that structure. And we're going to add shots only if we really need to. Zero shots means no examples. Sometimes you need a little help because CRE may not be enough. So you maybe add one example, but rarely do you add a few. Anything more than two is not going to be great. We'll cover that. Then excerpts. This is important. You need to give it facts. And when you're using examples, you need to be very explicit. Hey, these are style and format only. They're not facts.

9:57So in the next skill, we're going to cover CRE and then examples. This is the basic for prompt engineering. And then we're going to apply prompt engineering by using schema length cap, tone, macros, safety boundaries for paste ready outputs. This is where we go from prompt and guess to prompt engineering, which is exactly what you want when you're thinking about AI productivity for professionals. All right. So that's it for this video. And next up we have the challenge where you're going to try to match the output that I give you. And then in the next skill, we're going to apply prompt engineering and I'll show you how I came up with my CRE to produce that output. See you there.