YT YouTube2Text

YouTube2Text → Transcripts → Engenharia de Prompt: O Guia Definitivo

Engenharia de Prompt: O Guia Definitivo — Transcript

by Bruno Picinini · 16,174 words · 2,348 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00I read, studied, and tested the
0:02techniques from over 35 scientific
0:04articles by names and people like
0:07Google Mind, Meta, Microsoft, Alibaba,
0:09and also researchers from universities
0:12in Washington, Singapore, the
0:14University of California, and many
0:16others. I also thoroughly examined all
0:19the documentation of some of the
0:21largest language models to ensure I
0:23didn't miss anything when creating a
0:25good prompt and extracting the best
0:28results. In addition, I've created over
0:3020 customized agents that I use here at
0:33my company to automate tasks and save
0:35time, and which I also teach to all my
0:38students, generating thousands of uses
0:41for some of my agents that I make
0:43available on platforms, such as PL,
0:45where I have the third most used bot in
0:48the Portuguese language. This led me to
0:51become the first artificial
0:52intelligence consultant for companies
0:54in Brazil. And combining that with a
0:57massive study of all the courses I
1:00found, the demos, those obscure ones
1:02you only find after hours on Twitter,
1:05to finally test them all, the prompts
1:08and the output in literally millions of
1:11words, to now bring you everything
1:13pre-digested and ready to use. And
1:16that's why here's my promise to you: in
1:18this masterclass, you will learn how to
1:21do prompt engineering, that is, how to
1:23extract the maximum possible from these
1:26language models—this Ferrari that we
1:28have in our hands, but that few know
1:30how to use. All in a simple, direct,
1:33and practical way for normal people
1:36like you and me, who just want to make
1:38the most of these tools to help our
1:41lives, save work, and produce more.
1:44This entire class was designed to help
1:46everyone from beginners, who may have
1:48never created a prompt in their lives,
1:51to the most advanced, those who may
1:53even have some SAS or are developing
1:55some kind of chatbot. All so that you
1:58never again have to go looking for
2:00prompts and lists of 5,000 prompts that
2:02I see people selling out there. Never
2:04put it in quotation marks because it's
2:06a very long period, speaking of
2:08artificial intelligence, but certainly
2:10enough for this to be resolved and for
2:12you to have complete confidence in your
2:14abilities to achieve and generate the
2:17results you want. And how are we going
2:18to do this? We have seven modules here
2:21that I recommend you do in order, but
2:23if you want to skip one or revisit
2:25something, you can use the chapters
2:27below to skip ahead. So, what are these
2:29modules? The first one, fundamentals,
2:32where we'll see the basics and learn
2:34how to work correctly with long
2:36documents. The second is a basic prompt
2:39structure to put you on the right track
2:41. The third is the recommended process.
2:44What makes sense to think about in the
2:46prompt and what makes sense to think
2:48about outside of it, such as choosing
2:50the right model for the results you
2:52want. Then we move on to basic
2:54techniques that will help you get much
2:56better answers from your prompts until
2:59we reach more advanced techniques, such
3:02as creating interactive menus to make
3:04much more complex prompts that require
3:07more reasoning. Next, I'll show you
3:09some practical examples, both mine and
3:11others ', to show you how it all works
3:13in practice. And lastly, the
3:15recommended tools to help you
3:17accelerate all of this. And in case you
3:19don't know me, this is Bruno Pitnini
3:21speaking. I've already sold over eight
3:24figures online while visiting more than
3:2670 countries around the world. And on
3:28this channel, I want to help other
3:30entrepreneurs and experts do the same,
3:32to have a SED-type business, which is a
3:35simple, lean, fun, and scalable
3:37business, with the goal of not only
3:39achieving financial results but also
3:41more time and quality of life. So let's
3:48start with what makes the most
3:50difference and what we'll be using most
3:52throughout the lessons: the
3:54fundamentals. Starting with the
3:56definition. After all, what is prompt
3:58engineering? The simplest definition
4:01we'll adopt for the rest is prompt
4:04engineering. It's the empirical science
4:07, that is, based on real-world results
4:10and the answers we get from there, and
4:14not just theory, of planning, creating,
4:17and testing prompts to generate better
4:20answers in large language models. And
4:25why is it so important? Because it's
4:27the meta-skill that unlocks all others.
4:30Learning this, you can then use it to
4:33do whatever you want, for your own
4:35prompts, for students, for your company
4:38, for software, whatever. And it's so
4:41important that companies like, for
4:44example, Antropic, which makes Clode,
4:47used to have a job offer for a prompt
4:50engineer, and now the most current one
4:53they have is this one here, which is
4:55for a prompt engineering researcher,
4:58just take a look, salary of 315 to
5:01510,000 per year. If we put that in
5:04reais, it's roughly R $ 2,700,000 in
5:08Brazil. Obviously, that's a value in
5:10the United States, but it serves to
5:12show the importance of everything
5:14you're going to learn here. And to
5:16learn, what we're going to do is use
5:18what I once saw in a book by a guy
5:20named Josh Witskin, who co-wrote a book
5:23with Tim Ferriss, including about how
5:25to learn. And there he told the story
5:28of when he learned chess; the way he
5:30started was a little different from
5:32others, which was more like this. That
5:35is, he started with the endgame. Why?
5:38Because, in this situation of a king
5:40and a pawn against only one king, he
5:42focuses on the fundamentals without so
5:44many complicated things, without so
5:46many rules, to understand the essence
5:49of the game, in addition to learning
5:51this part that few people train,
5:53because sometimes they dedicate too
5:55much time to openings and the
5:57middlegame, and not the endgame. So in
5:59this lesson itself, we're going to use
6:01a similar process. We're going to start
6:03with the very basics, so much so that
6:06we're already here at the fundamentals
6:08and we'll build upon this skill so that
6:11both beginners can benefit, but those
6:13who want to advance and use it for more
6:16complicated scenarios or more complex
6:18cases also have the tools. And that's
6:20precisely why I like to use this
6:22example here, which is an egg. This is
6:24a reference I use when I give talks at
6:26events. I even like to interact with
6:28the people I mention to put the right
6:31mindset when thinking about the prompts
6:33, which again, are fundamentals. If I
6:35tell you how to make an egg, you might
6:37get several answers. At that point, I
6:39ask the audience to speak; some say fry
6:41, boil, but are you trying to say buy,
6:43or the question of the egg or a chicken
6:45, a philosophical question. I say
6:47exactly, that's the point. If you don't
6:49make it clear what you want, there's no
6:51way to know. This applies to both
6:53humans, which we'll see next, and
6:55machines. So, the first golden rule
6:57we're going to consider is this: what
6:59instructions would you give someone to
7:01do? Because if you show those
7:03instructions, which would be your
7:05prompt, to a person, they would be able
7:07to execute them. If they couldn't,
7:09depending on what it is, perhaps the
7:11major language models, like chat, EPT,
7:13Clou, GM, and many others, wouldn't
7:15work either. So, always remember this,
7:18it's a rule that, if we consider how I
7:21would instruct someone next to me,
7:24there's a good chance that translating
7:27it into a prompt will work very well.
7:30And you'll see how this simple rule
7:32will later have direct applications,
7:35from the simplest prompts to much more
7:37advanced techniques that you will learn
7:40here. But initially, what is most
7:42important? Start simple and then
7:45complicate. That's why we're going to
7:47follow this order. Don't complicate
7:49more than necessary. Do the basics.
7:51Simple prompts will work to solve most
7:54problems. Like two examples. Look here,
7:57I was in the GPT chat asking precisely
7:59because I wasn't sure if this was the
8:01author who gave this chess example,
8:03which I remembered reading, but I
8:05wasn't sure. So I didn't need to
8:07complicate things too much or use a
8:08technique or anything like that. I
8:10simply asked with the necessary
8:12information so that the GPT chat could
8:14find the answer I needed. And there are
8:17some things here about why it already
8:19gives a more detailed answer with other
8:20lessons that we'll learn later. Another
8:23one here, another prompt I was unsure
8:25about, like when the English says "
8:27don't invent stuff," I had the
8:28impression it sounded a bit like the
8:30Portuguese "do," your "con" trying to
8:32say "não inventa coisa"(don't invent
8:34things), and the more Americanized,
8:36natural way they would say it is "don't
8:38make things up." So, a simple prompt
8:41that I don't need to complicate further
8:43. Another important detail that will
8:45help you create better prompts is, as
8:47much as possible, to start with more
8:50expensive models that tend to perform
8:52better. For example, here at Cloud, if
8:54you go to their page, they have these
8:56three current models. The Opos, which
8:59is the most powerful of them, is about
9:01five times more expensive, depending on
9:04what you do. So that will make a
9:06difference. That's why I prefer to
9:08start with the best models, even if
9:10they are more expensive, and then
9:12reduce them later. I'm talking about
9:14more complex prompts, okay? The other
9:16simple ones, as I showed, aren't
9:18necessary, but when we want to push the
9:20limits of what can be done and get a
9:22very precise response, then it will
9:24make a difference. So start with the
9:27most expensive ones to eliminate that,
9:29don't try to optimize with the cheapest
9:31ones, because those are usually the
9:33most expensive, and then we go to the
9:35cheaper ones to refine and scale. Now,
9:37before we move on to a basic, super
9:39simple prompt structure, a warning,
9:42okay? It will get easier and easier,
9:44because we are now on certain models
9:46that are being trained, and the next
9:49ones, maybe when you're watching this
9:51video, we'll already be on GPT 5, 6, or
9:547, imagine when it's 10. So, it will
9:56become less and less necessary to
9:58complicate things so much and be more
10:00direct and simple. But some of these
10:03techniques that you will learn will
10:05still endure because they help organize
10:07the text both visually for us and for
10:10the machine to interpret. The main
10:12point I want to make clear here is not
10:15to overdo it, because it's not worth it
10:17, as it will become increasingly easier
10:19. As Naval often says, "aá" means that
10:22computers are learning our language
10:25instead of us having to learn theirs.
10:28So, for example, when I started in
10:29digital marketing back in 2010, I had
10:31to write HTML by hand, write all the
10:33code, integrate my website. Today, you
10:36click, drag, integrate, automate, and
10:38everything is solved. Because there are
10:40already no-code and low-code tools that
10:42solve this. And in terms of prompts,
10:45it's increasingly about knowing how to
10:47express yourself and communicate good
10:50ideas rather than complicated
10:52programming. Therefore, yes, learn how
10:54to create good prompts, as I will show
10:57you here, but beyond that, focus on
10:59having good processes behind them,
11:01having good communication—the golden
11:04rule. If this is a process that would
11:06be easy for someone to do, eventually,
11:08if the model can't do it now, it will
11:10become better. I even just participated
11:13in a meeting with a company that wanted
11:15my help precisely to automate their
11:17processes with agents. And what did I
11:19recommend to them? Don't just think
11:21about what the models can do now,
11:23because if you do that, when it's ready
11:26, you're already behind. Try to look
11:28and take a shot. Because the laws of
11:30scaling and exponentiality, as we're
11:32going, and I use this formula on my
11:34wrist to remind myself of this, that's
11:36what's going to happen. So plan for
11:39what will be available, maybe in one or
11:41two years, because then your time to
11:43build, the technology will already be
11:46there to deliver exactly what was once
11:48a dream, which will now be a reality.
11:51And with that, you gain a competitive
11:53advantage, because while they're
11:55looking back, you're doing what Peter
11:57Drucker said: what was the best way to
12:00predict the future, which is to invent
12:02it. Now, moving on a bit, we're going
12:09to see a basic structure for generating
12:12a good prompt, which, if in doubt, you
12:14can use because it will work for most
12:16cases, because then we'll go into more
12:19advanced techniques to expand on it. So
12:21, this technique, which I've coined
12:23with the acronym PROMPT, encompasses
12:26all of this. How does it work? Each of
12:28these letters represents one of the
12:30parts of a prompt's structure. Remember
12:35not to complicate things unnecessarily.
12:37What does the first letter of the P
12:38stand for? It stands for persona. You
12:41are an expert in marketing, social
12:42media, and human psychology, for
12:44example. So, since the training of
12:46these great language models has a lot
12:49of content, if we don't direct it, they
12:51won't be sure what we're talking about.
12:54So, we're giving them context before
12:56moving on to the second letter, which
12:58is the script. I want help creating a
13:00script for a res. This is an example of
13:03what I want to do for the third
13:04objective. The objective is to grab
13:06attention with a captivating story and
13:08then make a call to action to subscribe
13:10before moving on to the M model. How do
13:12I want this result? I want the result
13:15divided into 8 to 10 slides. This is
13:17just an example; later we'll see in the
13:19more advanced techniques how much you
13:21can work on this, especially if you're
13:23going to use it for other purposes.
13:25Overview. My client is an expert, sells
13:28online courses, blah blah blah blah. Or
13:30, in addition, later in some of the
13:32techniques we'll look at here, you can
13:34add more information as examples and
13:36many others that will greatly help with
13:38the results. And lastly, the issue of
13:40the "transform" part, which is
13:42important to understand. When we put
13:44the prompt there, don't expect it to
13:46give the perfect answer right away.
13:48Sometimes it will be an interaction, an
13:51initial base, it will send, give
13:52feedback, and do. And I'll even show
13:55you some techniques on how we can make
13:58this improvement, this optimization,
14:00both with your feedback and with the
14:03machine training itself. We'll see this
14:05calmly now. So, in this "transform"
14:07part, we'll give feedback. Change this,
14:09do this, do that, implement this,
14:12implement this. This is the basic
14:14structure of a good prompt, let's say,
14:19the 2080, which already works for most
14:21cases. Oh, and as a warning, don't be
14:22afraid to change the order, okay? This
14:24is one of the orders I put it in to
14:26make it easier. In fact, many times,
14:28when I'm creating a prompt, I literally
14:30start by typing those six letters and
14:32from there I begin typing my prompt,
14:34because then I know it will follow a
14:36structure. There are some things we'll
14:38see here, for example, if it's a very
14:40long document, this has to come before
14:42or after the instructions. This is
14:44important and makes a big difference in
14:46the result, which I'll now explain
14:47calmly. Given this, what process do we
14:54follow now? If a simple prompt didn't
14:57solve the problem, if this structure I
14:59just described didn't work either, what
15:02process do we use to develop more
15:04robust prompts that require a greater
15:06process of reasoning and logic to
15:08generate the result we want? So, the
15:10process recommended by a study I did of
15:13various companies, tutorials, and
15:15courses on how to do it is the
15:17following. It involves several steps.
15:19The first of all, the most basic and
15:22fundamental, is to define the task and
15:24the success criteria. This is very
15:26important because many people start
15:28developing the prompt or even the
15:30entire thing and don't even know where
15:32the goal is to score. They don't know
15:34where they want to go and it can't work
15:36. So, why is this important? There are
15:38three criteria for us to look at. First
15:40, performance and precision. How good
15:42does this model need to be, because
15:43depending on what you need, it might
15:45just be a generic response. Now, for
15:47example, I have a project with my
15:50mentees, where we help monetize
15:52knowledge at scale with agents. The
15:55type of response you have to give, with
15:57judgment, from COP, marketing and so
15:59many others, requires a very high
16:01degree of precision, to the point that
16:03I don't even use Chat GPT anymore and
16:04today I use Cloud more for some of the
16:06things we need, including in the
16:08clearer model. So this influences my
16:10decision on how to think about the
16:12process to create my prompt. Second,
16:15latency. What is the acceptable
16:17response time? Because more expensive
16:19models, not always, but for example, in
16:21the case of Cloud it's very clear, tend
16:24to be slower, because they have a
16:26reasoning process, a larger base, I
16:28don't know exactly how it works, larger
16:30. So, it takes longer to respond, but
16:32it's a more precise response. Now, if
16:34you're in an online chatbot, maybe you
16:36need a more practical response,
16:38sacrificing some quality, but to have a
16:40more instantaneous response, for
16:41example, if you're connected to
16:43WhatsApp. So that also influences
16:45things. And lastly, price. What's your
16:48budget for this? Because depending on
16:50what you're doing, it will make a big
16:52difference. As I showed here in the
16:54cost table, but in the cloud here at
16:57Haiku Pro Opus, there's a huge
16:59difference in terms of cost. So all of
17:01this will change a lot depending on how
17:03you think about the prompt. Once the
17:05task and the success criteria are
17:07defined, we move on to the second step,
17:09which is developing test cases. OK? If
17:12I want to get there, how do I know I'm
17:14close? How do I know that this prompt
17:17is generating the results I expect? So,
17:20we need to develop these test cases,
17:22mainly the standard ones, those that
17:25correspond to 80%, but also those that
17:27we call edge cases, that is, the
17:30exception to the exception. Could our
17:32prompt also handle that? It's worth
17:34including here, because then we can
17:36write an initial prompt. We can use
17:38that structure I just showed, the
17:39acronym prompt, at least to have a base
17:42and see if we're on the right track.
17:44Because, remember, the idea is
17:45iteration. We don't get it right the
17:48first time; it's a constant process,
17:50because we'll test against examples
17:52that we can judge ourselves or use
17:55other LLMs, other great language models
17:57, to judge and see if it's right,
17:59including suggesting improvements,
18:01refining this prompt. There are some
18:05prompts here that I'm constantly
18:07refining. I have, for example, an email
18:09editor that helps me with all the
18:11emails, which I write 100%myself, I use
18:13it as an editor. And almost every time
18:16I go there, I add some more
18:17modification that helps me identify and
18:20improve it more and more. So, it's like
18:22I'm training someone, but instead of
18:24training a person, I'm training this
18:27one so that this prompt, now ready,
18:29gets better and better and even more.
18:32And now I can share it with my students
18:33, which is really cool. So, refine the
18:35prompt and finally, put it into
18:37production. After it's ready, now I
18:38have many of the ones I have here,
18:40which are already in production, that I
18:42use constantly for the tasks I need.
18:48Having seen this basic introduction,
18:50we're now going to the techniques part,
18:53which I believe many people who hear
18:55the words "prompt engineering" would
18:57tend to think is what we're going to
18:59see now. But the important thing is, as
19:01I said before, to have these
19:03fundamentals that we just learned,
19:05because we're going to learn how to
19:07build from the back to the front, so
19:09that we can now add on top. So that's
19:11what we're going to do now. The first
19:13thing we're going to learn isn't a
19:15specific prompt engineering technique,
19:18but it's very helpful; it's about
19:21markdown. In case you're not familiar,
19:23markdown is this type of text here, for
19:25example, which has this hash symbol
19:27here and others. It's a type of text
19:29that can be converted; it's used for
19:32plain text, as we call it, but it can
19:34also be interpreted as titles and
19:37subtitles. So, for example, if I remove
19:39this hash symbol, it becomes normal
19:41text. If I add one, it becomes two. It
19:44becomes a heading, a heading one. If I
19:46add two, it decreases, because a
19:48heading two, three, and so on, which is
19:51what we use in HTML pages. There's also
19:53, for example, what's in WhatsApp,
19:55where if I put, for example, an
19:57asterisk around this word here, and an
20:00asterisk on the other side, it makes it
20:02italic. If I move my mouse away from it
20:05, and then two asterisks, it becomes
20:07bold. If I put, for example, an
20:09underline, it also becomes italic. And
20:12if I put this tilde symbol here, two
20:15tildes on each side, in this program
20:17here, it makes this strikethrough, it
20:19makes the strikethrough. And there are
20:22also other commands, for example here
20:24in Obsidian that I'm using, if I put
20:26two equals signs, it becomes a
20:28highlight. So there are different types
20:30of markdown and then we can even look
20:32for a markdown sheet, which is a quick
20:34and practical guide to markdown.
20:36Searching quickly on Google, I already
20:38found two that I can leave the link to
20:40below, if not just type markdown sheet
20:42sheet into Google and you should find
20:43them. So there's heading, bold, italics
20:46, code that you'll see we'll use a lot,
20:48lists, links and so many others. The
20:51main ones are these up here. There's
20:53another image here that you can use,
20:55but what's important in all of this is
20:57understanding markdown. First, because
20:59visually, doing it here in Obsidian
21:01makes it easier to locate things. And
21:04because these great language models
21:06learned from text, they replicate it.
21:09So, a well-organized text is very
21:12likely to work for the machine as well.
21:16Remember the golden rule I mentioned at
21:17the beginning? Here it serves to show
21:20you one of its applications. A
21:21well-organized text helps a lot for you
21:24and for the models to respond better.
21:27So, for example, in this prompt here,
21:29which is for summarizing tasks for
21:31mentees, which I showed in another
21:33video on this channel, I show and you
21:35can see how it's organized. I have
21:36headings to separate some of the
21:38sections. I have this type of tag that
21:42we'll call XML tags. There's bold,
21:45there's italics. I give indications
21:47that I want the response to come in
21:48markdown, because the type of response
21:50it gives is better later. I give
21:52examples and many others, and that's
21:54how I format it. So, visually it helps
21:56me, and I know that this gets a better
21:58response from the GPT chat, Cloud, or
22:00whatever. Actually, this is something I
22:03just discovered in my research: a
22:05well-formatted prompt gives a different
22:08response. In the cloud documentation,
22:10for example, they say this. And it's
22:12understandable why, if these language
22:14models are created to simulate how our
22:17brain works with neural networks, you
22:19just have to think about how you adapt
22:22the way you speak depending on who
22:24you're talking to. If you're going to
22:26talk to your grandmother or a close
22:28friend, your manner and the words you
22:31choose are different. So, in the
22:33language model it's the same thing. A
22:36well-formatted prompt is like the GPT
22:38chat, Claude or Gino understanding: "
22:40Here is a polite person, I will respond
22:43in the same way." So this is a type of
22:45response it gave based on this
22:47well-organized prompt, it gave this
22:49type of response. You can see that it's
22:52organized, which is what I showed in
22:54the last video, using markdown, using
22:56lists, bold, italics and everything
22:58else needed, in a way that is visually
23:00better for me and my students. Now,
23:02before we wrap up here, something
23:03important, two things I want you to pay
23:05attention to. This here and this here.
23:07What is this? This symbol is an
23:10extensive markup language, XML,
23:13extensive markup language. This is
23:16important because it's quite a bit in
23:18the cloud documentation, not so much in
23:19short, but it makes sense. It's very
23:21helpful because sometimes, especially
23:24with long documents, it's easy to get
23:26lost trying to understand what's a
23:29reference, what's an instruction,
23:31what's an example, and using this to
23:33separate them helps. So, you can see
23:36that here I've put the transcript, I've
23:39put it with this curly brace, and below
23:41you can see that I've put the slash to
23:44close this command. And when I refer to
23:47it, I would say, for example, this way,
23:50take this into account. Transcript,
23:52closes the transcript. This is
23:54literally in the documentation, so it
23:55makes a difference. So that's one of
23:57the things. Two. This is between these
23:59two brackets because this is the part
24:02where I know that I, or my students,
24:04when I give them some of the prompts,
24:07need to come and modify them. This is
24:09very good because look, if I copy and
24:11paste that prompt, put it here in the
24:13Antropic console, which is to test
24:15their model, you can see that it has
24:17already formatted this part of the
24:19transcription nicely. What does this
24:21mean? This is now a variable that, if I
24:23come to the site and go to this part of
24:26variables and click, it already gives
24:28me the space to just paste my
24:30transcription here. So it makes a lot
24:33of sense to leave these spaces with
24:35this command, because visually it's
24:38easier to find and some of the tools
24:40also interpret it correctly. And to
24:43close here, two more examples. I put
24:45this here because when I want it to
24:47create insights, I'm giving some
24:49examples and you'll see later in the
24:51more advanced techniques how much we'll
24:54use this type of markup to help. And
24:56here I give examples. Example of the
24:57original insight, example of the
24:58improved insight, because sometimes it
25:00wasn't producing what I wanted. So this
25:02helps a lot. And lastly, here's an
25:05extra tip: if you work with very long
25:07documents, because in this case, when I
25:09use this prompt, what goes into the
25:12transcript is a transcript of one of
25:14our mentoring sessions, from my 3-hour
25:16mentoring group, which is about 40,000
25:19words. That's a lot of text. And even
25:21in the other video I hadn't done this
25:23yet, and here I've already corrected it
25:24. When you have this, the template
25:27instructions themselves say this. When
25:29you have very long documents, include
25:31them before the instructions, which is,
25:34for example, what Antropic recommends
25:36here, structuring long documents. When
25:39working with very long documents, use
25:42XML tags, which helps a lot, or XML.
25:45And in terms of positioning, position
25:48them first and then put the
25:50instructions below, which is exactly
25:53what I did here. I'll give you the
25:55transcript. Pay attention because I'll
25:57ask you questions later. Here you would
25:58have the transcription and then the
26:00instructions for that prompt. Therefore
26:03, for long documents, put the
26:04instructions first. But there are some
26:07cases when the document is not only
26:08long, but it's also divided and broken
26:10into sections. Then there are some
26:12problems that we have techniques on how
26:14to solve, which I will show mainly in
26:17the examples I will show here at the
26:19end of the lesson, when we will put all
26:21or almost all the techniques together
26:23in one place. As a second technique,
26:25let's say, we're going to see what a
26:27prompt is. This helps a lot to refine
26:31the result you get. What is this for?
26:34If you look, for example, here in the
26:36Antropic console, there is a prompt in
26:37the system. This is when you put a
26:40message about how you want the system
26:42to act. So, some examples are, for
26:44example, instructions for a task,
26:47answer in a certain language, answer in
26:49a certain way, answer in a Socratic way
26:52or in questions or in logic and so many
26:54other things. So this helps a lot in
26:56the interpretation of your prompt,
26:59better results, as I said, answer in a
27:01language, something like that. So here
27:04in my GPT chat, if I go to the GPT chat
27:07customization section, here are some
27:09things that part of this prompt I got
27:12from my friend Alan, which we created
27:14together in the past. So I adapted some
27:17of the things for myself. Here it asks
27:19what it should know about me to give a
27:21better answer and how it should respond
27:23. In this case it's deactivated now,
27:25but it could be activated. And it will
27:26do some of these things. And here in
27:28this part of the system prompts, which
27:31is one of the techniques we're going to
27:34use to significantly reduce
27:36hallucination and help with the quality
27:38of the responses, which we'll see later
27:41in some of the techniques. These system
27:44prompts themselves aren't always used,
27:46but it's worth considering because if
27:48it's something very repetitive of a
27:50certain language style that you want
27:52the model to act on, it's worth
27:54including. As a third technique or
27:57prompt strategy, we have what we call
27:59zero shot. And you'll see this term
28:01repeated many times. What does it mean?
28:04The model is trained on billions of
28:06parameters. When we ask it a question
28:09without any references or examples, we
28:11call that "zero shots," meaning zero
28:14examples. So, interpret "shots" as
28:16examples for the model to follow. You
28:19can see here, for example, that in this
28:21prompt, I was asking for help
28:23optimizing the title I was creating,
28:25asking how to better organize this
28:27sentence to make it clearer. I simply
28:30pasted my title. I didn't give any more
28:32examples or shots of what an expected
28:35title is, how I believe it should be,
28:37because that would certainly improve
28:39the answer. But in this case, I just
28:41wanted to get straight to the point:
28:42tell me how to improve it. And here it
28:43gave some suggestions on how it would
28:45do it. But obviously, and we'll see
28:47shortly, with examples, the answer is
28:49absurdly better, which is one of the
28:51techniques we use. So here it did that,
28:54gave more suggestions. In another
28:56prompt, I sent another title I was
28:58working on and it told me how to
29:00improve it. I didn't give many
29:02alternatives; in fact, I asked it to
29:03generate alternatives for me. So this
29:05is the Zero Shot, which I don't give
29:07any references for, I just ask my
29:08question very directly. And now we're
29:10starting to get into some techniques
29:12that aren't super advanced, but I want
29:14to show you their origin to explain
29:16them better and also to understand that
29:19it's not simply a few little videos on
29:21YouTube generating lists of prompts.
29:23There are scientific studies by serious
29:25people in the field, and I want to show
29:27you some of them because it's the
29:28research I did and have already
29:30interpreted for you so you wouldn't
29:31have to read all of this. So, one of
29:33them here, in this paper here, from
29:36people at the University of California,
29:38Santa Barbara, and Microsoft, they
29:40demonstrate and prove, they show here
29:43this technique called directional
29:45prompt stimulation. Something that
29:47doesn't seem complicated to me, 27
29:49pages of a study that I've already
29:51understood, already translated for you,
29:52which is this idea here. And I'll show
29:54you an example. What's the idea? In a
29:57normal prompt, it would say, for
29:58example, to summarize the article in
30:00two or three sentences and give a
30:02certain sentence. And here's a score
30:04that was achieved. If you simply make a
30:07super simple modification, based on the
30:09tips I'm translating directly from
30:11English, and give these tips, his
30:14response will already be much better,
30:16because now you've directed what you
30:19want through this stimulus. Let me show
30:21you a practical example. I took another
30:24paper that we'll see later in the
30:27techniques section, called Skeleton of
30:30Thought. And to help me interpret all
30:33of this, I put it here using PL, which
30:35is one of the A tools I use, in the
30:37Opus model, which is the best in Cloud,
30:39200K, with a larger context window. And
30:41here at the end, the first tip I gave
30:44before, I put the document before, and
30:46here at the end I asked him to
30:48summarize all of this. But instead of
30:50just giving instructions to summarize,
30:52I came here and said: "Organize the
30:55markup in an organized way using the
30:57keywords below, which is exactly what
30:59came from there." So, I used keywords,
31:02I put a command here to differentiate a
31:04bit: examples, practical application,
31:06results, and comparisons, because that
31:08way I know that with this directional
31:10stimulus, it has a greater chance of
31:12finding the right references and
31:14organizing them in the best way that
31:16interests me. This is a super simple
31:19technique, but it helps a lot,
31:20especially when working with large
31:22documents that we're going to use. And
31:24then, this very one that I showed,
31:26which I used as a reference for this
31:29thought framework, you'll see how it
31:31works to create something even more
31:33robust. The next technique we have is
31:35relatively simple, but when used well,
31:38with a well-calibrated prompt, it will
31:41already generate most of the results
31:44you need. It's called fu shot. What
31:47does that mean? What did we talk about
31:48before? Zero shot, where I don't give
31:50any references. Therefore, in the fu
31:52shot, I'll come here and do this, look
31:54at the difference it can make. This
31:56here are the results they showed of how
31:59much precision with zero shot, one shot
32:01, which is just one example, or f,
32:03which is several examples. And the
32:05improvement is significant, it's really
32:07huge. So, as an example, a prompt I use
32:10, which is an infinite title generator,
32:12that I give to my students and mentees.
32:14Instead of simply giving the
32:16instructions I already have here, I
32:19also give examples of what good titles
32:22are. Some of the references I got from
32:24big names, like John Benson, Stephen
32:26George, Craig Clemens, and other
32:28copywriting guys. So I put these titles
32:31here as examples, the explanation of
32:33each one, because what is this?
32:35Remember the golden rule? If I were to
32:38ask someone to do it, if I show them,
32:40create a title here, example of 20
32:42winning titles that worked for us, what
32:45is the chance that this person would
32:47produce a better result? So, all this
32:50study is basically to say that. Put
32:52examples. And we'll even see what types
32:55of examples work best, but simply
32:57giving positive examples already helps
32:59a lot. Going back to our basic
33:01structure that I showed before, these
33:03shots or examples are what I would put
33:06here in the overview section, where I
33:08not only give information about my
33:11client or whatever else I want, but
33:13also better guide the model and produce
33:16a better result, a better answer. The
33:19next technique we're going to learn is
33:21one of the most famous and it's called
33:22chain thinking. This one is very good
33:25to use when it requires a line of
33:28reasoning and logic, for example, for
33:30arithmetic or complex problems, more
33:33than just a, let's say, raw answer. How
33:36does it work? I'll show you an example.
33:38So, in this paper here from the Google
33:40research team, as you can see here,
33:42they did these tests. So, here's a
33:44normal prompt, where there's a logic
33:46problem and the wrong answer. In this
33:49chain of thinking, they include in the
33:51input, that is, in the prompt they put,
33:53an example of the question and how the
33:56model should behave, which in this case
33:58is to do this chain of thinking, which
34:00is how we would do it. This would be a
34:03bit like those logic and reasoning
34:05interview questions they sometimes ask,
34:07or claim to ask, like: "How many
34:09balloons fit in this room?" You
34:11wouldn't go crazy and say 26, would you
34:13? No, right? You'd probably do a
34:16step-by-step process thinking, okay,
34:18what's the size of the balloon? What's
34:20the size of this room? How many meters?
34:22You'd do a multiplication and then try
34:25to estimate based on that, not just
34:27guess. So these techniques try to
34:29simulate this reasoning process,
34:32because that's how we do it, and with
34:34that we get a more precise result for
34:37more complex problems. Notice again how
34:40many times we go back to the golden
34:41rule. Try to think about what the most
34:44appropriate process would be for us to
34:46solve the problem. And that's what this
34:48does. It shows how this model should
34:52work. I'll show you an example that
34:54isn't exactly this, but in a way it's
34:56where I was trying to solve a problem
34:58on my website. I had a code for a Vurb
35:01sales video, which is a tool we use,
35:04that was causing problems. And instead
35:06of waiting for a response, I came here
35:08to the EPT chat, posted the code, and
35:09explained my problem. This is giving an
35:11error. Please help me, because I don't
35:13understand it well enough. He modified
35:15the code and then, because this is in
35:18the instructions behind it that we'll
35:20see later, to avoid hallucination, he
35:23helps me explain what was done. Because
35:25this not only helps me understand what
35:28he did to implement the solution, but
35:30also helps him think and give me better
35:32answers. And we continued, it's still
35:34not working. Then he made a new change
35:36and explained it to me and gave me
35:38debugging suggestions. If this isn't
35:40working, let's try this to try and
35:42adjust it. So that's the chain of
35:44thought. When you have a bigger logical
35:47reasoning problem, letting the models
35:50think explicitly works better. And here
35:53in the Cloud, they give some more
35:55suggestions on how to take this further
35:57and produce even better results. For
35:59example, regarding a question they
36:01posed to me here, which requires a
36:03certain type of reasoning, they suggest
36:06breaking it down step by step to arrive
36:08at the answer. But what you can do, and
36:11this depends on where you're going to
36:13apply it, is use the XML tags I showed
36:15earlier to separate what is thought
36:17from what is the answer. And you'll see
36:20how we'll use this later in the
36:21hallucinations. So here it instructs
36:23you to think using a space for "
36:26thinking" and then put the answer
36:28inside "answers." This is very good. If
36:31, for example, you want to develop a
36:32SAS or some platform on WhatsApp to
36:34provide answers, you can have a space
36:36and then do some filtering where the
36:38model thinks, for example, if it needs
36:40to do some calculation, and the answer
36:42is only within these specific tags so
36:44that the client doesn't see what they
36:46shouldn't see. And in this case, I was
36:48talking here with Professor Sandec from
36:50his channel. I recommend it to anyone
36:51who wants to follow him. This guy is
36:52really skilled, he understands what
36:54he's doing, he truly understands the
36:55subject matter, and not just like many
36:57who watched a few YouTube videos and
36:58now think they're experts, teaching
37:00like professors on the subject. And I
37:01was talking to him about this. Can the
37:04model perform this type of reasoning
37:07internally? Because here at Cloud they
37:10explicitly say so. It's important to
37:13note that this thinking cannot happen
37:16without output, without results. Cloud
37:18must produce its own thinking to truly
37:21think. What's the disadvantage of this?
37:23Cost, because the output is the most
37:25expensive, 75 per million tokens, in
37:27the case of Cloud, in the most advanced
37:30model. So, yes, if necessary, fine, but
37:33there's a cost. And then we were trying
37:35to see if this would make a difference
37:37or not in other models. The answer is
37:39that for other models, for GPT chat, it
37:41seems there's some kind of internal
37:44process, but I'm not 100%sure. For
37:46Cloud, they explicitly say: "You have
37:48to make Cloud produce this thinking
37:51because otherwise it won't use it as a
37:53reference." And on top of that
37:55technique, we're going to the next one,
37:57which is the chain of thought, let's
37:59say, which is from the people in
38:01Singapore and Alibaba, which is super
38:03simple, thinking about what we just
38:05learned in terms of how to put the
38:06steps to do it. What helps a lot with
38:09some models more than others is not
38:11only giving the model the correct
38:13explanation, like "this is the answer I
38:16want," but also giving the wrong
38:18explanation, like "this is what I don't
38:20want," because that way the model can
38:22learn from both the correct and
38:24incorrect examples. Okay, Bruno? I
38:26understand the chain of thought, but
38:28how do I ask these questions, give
38:29these answers, and provide instructions
38:31? Sometimes it's already obvious, you
38:33already have examples you want to
38:35include, but there's a shortcut from
38:38another study on how to shorten this a
38:40bit, which we can even use in the
38:42system prompt instructions, which are
38:45zero-shot reasons, which they called
38:47the chain of thought with zero shots.
38:49What is that? This is very simple, okay
38:52? Everything we talked about before
38:54regarding the chain of thought, where
38:56to put it, giving the instructions on
38:58how the model should think. If I don't
39:00have that, simply instructing the model
39:03to speak, let's think about this step
39:05by step. Breathe calmly and think
39:08logically step by step. Sometimes, in
39:11more advanced models, it's enough for
39:13the model to naturally do this whole
39:16process without you having to
39:18explicitly give examples. It doesn't
39:21always work, it depends on what you
39:23want, but it often helps. And now with
39:25this you understand when, for example,
39:28when launching the GMini 1.5 Pro to
39:30interpret tables like this, what do
39:32these tables mean? These are the names
39:34of the tests. You can search on Google
39:37or Perplexity to find out what
39:39different types of tests they use to
39:42compare models. And that's what these
39:4510 shots, five shots, 11 shots mean,
39:48which means that in the model inputs
39:50they put 11 examples of what they
39:53wanted. And even if you look down here,
39:56for example, in this one, formatted as
39:59CT problems, that is, chain of thought
40:03problems. That's what this acronym
40:05means, including some with zero shots
40:07for comparison when you don't give any
40:09examples of how they perform. The cool
40:11thing is that by understanding all this
40:14, you can now better interpret when
40:16they post graphs like this or those
40:18comparative tables of models. That's
40:20why when Gemini Ultra came out, I
40:22wasn't so impressed because there's a
40:24detail here that I don't know if you
40:26noticed, but I'll show you now. First,
40:29here they are reporting against GPT4,
40:31right? Sota means state of the art
40:34model, that is, the best model on the
40:36market at the moment, which was GPT4.
40:38But look, remember we learned what
40:41shots are? In this one, they are
40:43comparing one with a COAT chain of
40:46thought of 32 shots compared to one
40:49with five shots in GPT4. That makes a
40:53big difference. So they post this as if
40:56it were something incredible. But is it
40:59really? You can't be 100%sure,
41:00especially since Google is kind of
41:02desperate. And it's funny, besides, a
41:04little extra comment, this graph is
41:07like a rocket exploding towards the
41:09moon, but if you put it into
41:11perspective, it's more like this. It's
41:13not such a big change comparatively.
41:15Yes, it is, I know that on a
41:17logarithmic scale things are getting
41:19better and better, but because we need
41:21to be doing very well, thank you. And
41:23if you look at it in other ways, it's
41:25not so amazing anymore. But anyway,
41:27it's worth emphasizing again. Choosing
41:29the right model will make a big
41:31difference in the final result. The
41:33same prompt you run on GPT, on Gem, or
41:36on Cloud will give a completely
41:38different response. In general, I've
41:41been using the cloud on most of the
41:43time, but there are certain commands
41:45that I've used on Gemini or GPT and
41:47produced better results. It depends on
41:50your goals. No, it just depends on how
41:52it changes with each update, so you
41:54have to keep testing and monitoring as
41:56things change. Now, at this moment, a
41:59warning. Remember I said we were
42:01building on top of the skills? What
42:03you've seen so far is, honestly, more
42:05than 2080. For most people on this
42:08channel, it will already be enough.
42:11What we're going to see now are some
42:13techniques that delve deeper into more
42:16complex prompts to produce better
42:19answers. Anyway, even with that said, I
42:21recommend you keep watching. Why?
42:24Because first, it's super interesting.
42:26Second, it will give you ideas on how
42:28to expand your mind and then, for a
42:30prompt, produce better answers. And
42:32third, it serves as a reference in case
42:34you want to create something bigger or
42:36impress your friends with your
42:38knowledge; you'll already know how it
42:40works. And also because many of these
42:42next techniques will be shown and
42:44incorporated into the examples I'll
42:46show here at the end. Starting then
42:52with the most advanced, the first one
42:55is called self-consistency, which is
42:57the one in this paper they released
43:00through Google. Where what they say
43:02here, right off the bat, is that the
43:05chain of thought technique has produced
43:08excellent results, but the risk is that
43:10, as it works, it's a bit naive.
43:13Sometimes it generates a line of
43:14reasoning, but it's not the right one,
43:16and that causes an error. How do they
43:18...one of the ways to solve this (and
43:20we're talking more specifically about
43:22prompts here, but perhaps, if you're
43:24more advanced, you could even run them
43:26in parallel) is that they suggest that,
43:28instead of generating just one chain of
43:30thought, you generate three, and then
43:32the model itself compares the three to
43:34see which one has the highest chance of
43:36producing the final result. So, this
43:39isn't something I use all the time, but
43:41I thought it was interesting to show
43:42for a reason I just mentioned, to give
43:44you an idea. Because, if you're having
43:47difficulty and see that the answer you
43:49want isn't coming, is slow to come,
43:51perhaps incorporating some of these
43:53more advanced techniques, generating
43:56multiple answers, might help you. Even
43:58if it's not for the model to judge
44:01itself, but so that you can visually
44:03judge and say: "I liked 2, 3, and 7". I
44:06often use prompts like this: I generate
44:0810 suggestions, like some we'll see
44:10here, I choose three and work on those
44:13three, because that way I have a better
44:15chance of success. Next, we now have
44:18the thought chain for the thought tree,
44:21which has two papers here: one from the
44:24DeepMind team and another from a lab in
44:27San Jose, California, where they talk
44:30about this thought tree technique,
44:33which is, again, expanding the thought
44:36chain to get even better results. How
44:38does it work? Visually it's easy to
44:40understand, but the practical
44:41application is not so much. Here they
44:44show an initial example of the basic
44:46prompt, input, output. Here they show
44:49how the thought chain, abbreviated CT,
44:51works and what we just saw about
44:53self-consistency, where we generate
44:55multiple responses and from there
44:58choose those that have the highest
45:00chance of being correct. What they
45:02recommend here is that this is for more
45:04complex problems, and that's why many
45:06of these more advanced techniques,
45:08sometimes they add up to something
45:09really cool, seem incredible, but don't
45:11have much practical use, or at least
45:13not for most people. So I'm going to
45:15show some of them here, because it is
45:17possible to incorporate some of these
45:18things, as I will show, but not as much
45:20as what we saw before. But the idea is
45:22to develop a knowledge tree here, where
45:25these alternatives are studied so that
45:27from these possibilities, because it's
45:30a process that resembles how we think.
45:33Let's solve this problem. Hmm. We can
45:35do one, two, or three, but this one has
45:36this problem, this one. You know how we
45:38develop it? That's the idea, to try to
45:41replicate this reasoning process within
45:43these models. So, in this, this type of
45:46study here, this is another paper they
45:48did that's similar, but it has, let's
45:50say, a router that they use internally
45:52to generate the results. How would this
45:55be in practice in terms of a prompt?
45:56There's a guy I found here on GitHub
45:58who made a suggestion that I adapted.
46:00And here he mentioned that he read
46:02about this role and he suggested this
46:05prompt here, which incorporates this
46:07idea he talks about: "Imagine three
46:09different experts and they talk to each
46:11other and we let the model do it." And
46:14look how I did it in practice here,
46:15because I even went further. I used
46:17this tool called [tool name] that
46:19allows me to talk to two, three, four,
46:22or six models at the same time. And in
46:24this case, I set it to talk to the GPT
46:26chat and the Cloud to compare the
46:29response. So what I did, which was one
46:31of the techniques I was studying to
46:33test the application of this, I created
46:35three personas: one that is the
46:37copywriter who writes the headlines,
46:39the prospect as if they were my
46:41potential clients judging, and a
46:43manager who gives instructions to the
46:45copywriter. Then I create a loop here
46:48using commands, again, notice that I'm
46:50using XML tags, as I said. And here I'm
46:53going to do this process. I want you to
46:54execute it. And then, as the copywriter
46:57writes, the prospect judges, the
46:59manager takes this feedback and passes
47:01it on. So they start here and go
47:03through this process. I understand the
47:05information, pass it to me so I can
47:06begin. Then I said, okay, I passed
47:08along some of the titles I had shown in
47:10the other one, and he, the copywriter,
47:11starts making some suggestions, then
47:13come suggestions, then feedback from
47:15the prospect, suggestions from the
47:17manager, and so on. And here he makes
47:18the next one. Then I just said, "
47:20Continue," and he keeps repeating this
47:22process. So I could do this several
47:24times until I was satisfied to see
47:27other ideas, suggestions. But, instead
47:29of it having to be me, or someone from
47:31my team, or someone else giving
47:33feedback, or if I wanted, I could come
47:35here to where I typed "continue," and
47:37give my own feedback to this manager,
47:39which would simulate, in a way, what
47:41the structure of my company would be
47:43like, so that they could incorporate
47:45what I said and put it here for
47:47judgment. So, this is one of the
47:49applications I'm showing here as an
47:51example. I even want to do some more
47:53advanced tests on it because I see the
47:56potential of how you can take this
47:58technique we just learned about the
48:00tree of thought and have a real
48:02application for your prompts. The next
48:05one we have is one I mentioned before
48:07called the thought skeleton. This is a
48:10paper from people in China, the United
48:12States, Belgium, and other places. And
48:14what's the idea behind this? I was
48:16already applying it in a certain way,
48:18but it was interesting to learn how to
48:21do it in a more structured way because,
48:23in fact, this paper, this study, is
48:26more for internal training of the
48:28models than for the prompt itself. But
48:30what did I do? I took all of this,
48:33which is 51 pages, gave it a good look
48:35and read it, saw the prompts they gave
48:37as examples and suggestions. And where
48:39did I apply it? First, I went there—
48:41remember I showed you that I used Poll
48:43here to interpret, to help me interpret
48:46this study and give me suggestions? And
48:48then something I was already doing,
48:50which I want to show you now, an
48:51example of how I use this, already
48:53mixing some techniques. So here I am in
48:54the guide. So here I am in the
48:55implementation guide of my mentorship
48:57program, which is the Exponential
48:58Expert program. And here in the
48:59marketing part, I have what I call the
49:01main surprising cause, which is where
49:03we create a unique mechanism for the
49:04problem. If you don't know what that is
49:06, that's okay now, but it's basically
49:07to differentiate from the competition.
49:09And in this one, to help me create,
49:11instead of giving a direct answer, what
49:13do I do? And I'll show you here as an
49:14example. So here I have a specific
49:17agent that does this. It gives the
49:19instructions. I first sent the data
49:20from my client that I generated with
49:23other people that I showed before. And
49:25here now, instead of immediately asking
49:28for the definitive answer, I ask it to
49:31generate a thought process framework,
49:33which is basically generating a list of
49:36possibilities we can pursue. It even
49:39has this name, "thought process
49:41framework," with scientific study, but
49:44it's a reasoning process for how we
49:46would make good decisions: a brainstorm
49:48of ideas for us to put in now, judge
49:51them with a quick explanation, but this
49:53could also be adapted, for example,
49:55into a processing of some reasoning to
49:58judge and move on to the next steps.
50:00What do I do now? In this model, I
50:03create a kind of menu so I can, for
50:05example, give feedback, explore more
50:07options, and choose more. And I, okay,
50:10I put letter A, let's explore a little
50:12more, I sent more details. Remember
50:14what I said before? Not just machine
50:16feedback, but human feedback as well.
50:18I'm guiding my feedback as if it were a
50:21person next to me towards what I want.
50:23I understand. It made more suggestions,
50:25I thought it was good, it gave me more
50:27suggestions. Now combine these.
50:29Remember when I said we were going to
50:30do this? And now he's starting to do it
50:32. I'm developing it because it's faster
50:35this way, and I also save tokens if I'm
50:37using an API rather than having him
50:39develop what we're going to do every
50:41time. I chose a specific one here, and
50:44then I ask, now I want to detail what's
50:46embedded in this agent, the explanation
50:48of what I want, which is to create a
50:50technical definition, a simple
50:51definition, and an elevator pitch, plus
50:53metaphors and brand suggestions. I
50:56pre-program all of this so that my
50:58students and mentees already have these
51:01suggestions to explore together. We go
51:04back to our work that we do weekly and
51:07bi-weekly to explore together what the
51:10best ideas are. Including finding some
51:12suggestions for arguments, what
51:15information and evidence I need to use
51:17so that this argument I just created is
51:20more, not just more, truthful, so I can
51:23prove what I'm trying to say; including
51:25finding arguments to help me prove what
51:28we just created. So he finds all this,
51:31goes through the whole process, gives
51:32me back the options of what I want to
51:34do, and so on. So that's the idea.
51:36Instead of starting with something
51:38already super complex, I develop at
51:40least a structure as if it were an
51:42index of what I want to do, and then I
51:45develop it step by step. This is very
51:47good, and I use it a lot, for example,
51:49when creating a longer COP (Cost of
51:51Action). I know there are seven steps I
51:53have to hit, things I have to do, but
51:55instead of doing it all at once, which
51:57is very difficult and carries a high
51:59risk of error, we subdivide it, and
52:01with this reference, we work point by
52:03point. The next one we have here is
52:05this one, which is knowledge generation
52:07through prompts. And you'll see that as
52:09we advance, some of these techniques
52:12become less and less practical. They're
52:14really only for extreme cases, but in
52:16this one I'll show you how I used it.
52:18What's the idea behind this? It's about
52:20generating knowledge that the AI itself
52:22, the model itself, generates to use as
52:24a basis for generating subsequent
52:26answers. And although it's something a
52:28bit more advanced, on a large scale
52:31this is what companies like OpenA and
52:33Meta consider doing to train their
52:36models, that is, generating a kind of
52:38synthetic knowledge, content to use and
52:41train the models. So it's not a bad
52:43idea at all. How did I use this? In the
52:45other prompt I showed here, when I was
52:48creating a profile of my ideal client,
52:50which is to make a 10-word title. If
52:52the model has more information about my
52:55client, the chance of it getting those
52:5710 words right is greater. So that's
52:59what I do here to generate a profile of
53:01the ideal client. I passed some
53:02information and it generated this whole
53:05profile with various pieces of
53:07information that I then use to generate
53:09the next steps. Sometimes it's not
53:11about generating long texts, but even a
53:13title. That's more information and
53:15context that helps improve the answer.
53:17The next one is the Maieutic prompt.
53:20It's one I haven't used as much. Yes,
53:22it does have applications, again, in
53:23certain cases where you might be having
53:25difficulty. The idea is to use a
53:27teaching technique that we already use
53:29in school, again remembering the golden
53:31rule, more similar to how we learn,
53:33which is to justify your answer. So we
53:35ask the model to give the answer and
53:37justify it, because then perhaps it
53:39itself understands what mistakes it is
53:41making and thus also improves the
53:43answer. The next one we have here is
53:45the reasoned generation of recovery,
53:47which I have already translated
53:49directly here. This is an article from
53:51Meta, where they talk about one of the
53:53limitations of all these models. We
53:55talked about the techniques of first
53:57shot, zero shot, chain of thought, but
53:59there is a limit to how much I can put
54:01into the prop, because I have, for
54:03example, all my knowledge base from my
54:05classes, transcripts, files, videos and
54:08podcasts. So here they suggest that
54:10this is the next step. This is already
54:12much more advanced, which I know most
54:14people here will not apply. But for
54:16those who really want to advance and
54:18get even better answers, it's not just
54:21about putting it in the prompt: you
54:23combine language models so that they
54:25work with an external knowledge base to
54:27argue the answer and, with that, again,
54:30produce a much better result. I'll show
54:32you two examples now. One a little like
54:35this, not exactly what they talk about
54:36in this article, and the other a little
54:38more advanced, but also nothing crazy,
54:40so you can see how this works in
54:42practice. So I'm here in Obsidian,
54:44which is the tool I use for note-taking
54:46. And I'm going to show you what the
54:48idea is, because as I said, relying
54:50only on the prompt itself has a certain
54:52limit. Yes, we'll put this information
54:54in the prompt, but ideally we should
54:56have a way to consult other information
54:59, other knowledge bases in a dynamic
55:01way. I'll show you a super simple one
55:03here. So, here in Obsidian there's a
55:05plugin called Copilot, which is the one
55:07I'm using, that integrates different
55:09models that I connect to my API. In
55:11this case, I'm using Clode because I
55:13like it a lot. And here I can see in
55:15the chat and connect some of this
55:17information that I already have saved,
55:19which I use to do what I need. So I
55:21would say something like, use the
55:23information you find when I press the
55:26bracket; it brings me this menu where I
55:29can literally link this article that's
55:31here, and it will put that information
55:34in my prompt. So, use the information
55:36you find in persuasive premises and
55:39then consult my client profile, which
55:44is here, using what you learn, client
55:487D. And now I press enter, and behind
55:51the scenes it will do this and send
55:54this information to create it. So the
55:56advantage is that with a prompt that,
55:58in theory, if you look at it, is
56:00relatively small, it's just this. But
56:03what happens behind the scenes? I'm
56:05sending all this information that's
56:07here. Here, there are some details of
56:09what I go through in my mentorship
56:11program about seven criteria that I
56:13want the person to look at to design
56:14the profile of an ideal client. And
56:16here's an overview of my client that
56:19I've already designed, from the
56:20mechanism and offer to who my client is
56:23, with more specific information. And
56:25based on that, it can give me a much
56:27better answer, as you can see here. So,
56:30that's one way to use it. Now, there
56:33are others, for example, if I come here
56:35to this tool, which is ChatBase, which
56:38you might know, that uses the Open API
56:40behind it to create a chatbot: here I
56:42show how it's used, but in a more
56:44dynamic way, where I have a chat that
56:47could be embedded in my page, on
56:49WhatsApp, on Instagram, or in other
56:51ways. And I created a simple
56:53conversation just testing what the
56:55one-to-one rule is, which is one of the
56:57concepts I teach in my mentorship
56:58program. And it gives this answer. You
57:00can see that this isn't an answer it
57:02pulled from its training database. It
57:05went to the documents I uploaded here,
57:07which we trained on. Flávia helped me
57:10do this, and from there, he gave the
57:12answer and gave an example I wanted,
57:14strategies on how to use it, and then,
57:16what is the 7D profile of a client as
57:18well, which is this concept I just
57:20showed that's in Obsidian, it's in my
57:23classes; he takes this and returns it
57:25as an answer. All of this here has some
57:27information from the model, the
57:29temperature that is used, which I
57:30mentioned before. We come here to this
57:32panel of this tool, which is the base
57:34chat. And what did we do? We train it
57:37so that it can respond with this
57:39information. So now we don't just give
57:42answers based on the prompt or what
57:44that model has in terms of information,
57:47but we pull in external knowledge and
57:49upload it through files. You can see
57:52that we uploaded the transcript.
57:53Actually, not just the transcript, okay
57:55? There's a right way to handle this
57:57information to upload it here. And
58:00giving you a tip, the best way is to
58:02use a question and answer format. So,
58:04there are prompts we use that transform
58:06the transcripts I had from my classes
58:09into questions and answers, because it
58:11more closely resembles what will happen
58:13when someone comes here to a chat;
58:15they'll probably ask questions. If that
58:18question is as similar as possible to
58:20what's already in their training
58:22database, the chance of them answering
58:24with greater confidence is higher,
58:26which is what happens here. So I have
58:28here not only the transcript files, but
58:31also the processed transcript files
58:34that we uploaded here. I could also
58:36upload more from my website, which
58:38would then be more or less a questions
58:40and answers section, and even from
58:42Notion. So here in the Questions and
58:44Answers section, we come here to add
58:46some of those questions that perhaps
58:48weren't covered or weren't good enough,
58:50which we can see here in activities, at
58:52least in this tool here. Here I come
58:55and you can see my chat, and here it
58:57gives me a confidence index of how well
58:59it's been answering. My confidence is
59:02low. Here it's 0.88, here it's 9.50. So
59:06, depending on how much of that
59:08knowledge he believes he has in his
59:10training database, he'll give a better
59:13answer. So this, let's say, this
59:15article they describe here, is a way
59:18that you don't just solve it with the
59:20prompt; it's the prompt with an extra
59:23knowledge base to add this information
59:26and, with that, generate the closest
59:28possible answer to what you already
59:31know, whether it's from a class, a
59:33transcript, a PDF, or articles you've
59:36already created that you feed into some
59:39tool. Here I only showed one of them,
59:40but there are so many others to
59:42generate the perfect answer. Now, this
59:44one I found very interesting, which is
59:46how to use programming language
59:48techniques, but in language models. So,
59:51what's the idea here? They demonstrate
59:53in this example how they used, for
59:55example, the creation of variables to
59:58use in the reasoning chain of the model
1:00:01. How did I use it? When I make, for
1:00:03example, announcements that I send to
1:00:04students and mentees, instead of having
1:00:06to put them in the middle of the text,
1:00:08I used this idea of variables and I
1:00:09create them and put them at the
1:00:11beginning. Using my XML tags here, I'm
1:00:13placing variables I created, for
1:00:16example, audience, main promise,
1:00:19misleading culprit, and then below I
1:00:21have an ad template where I leave space
1:00:25for these variables. This makes it
1:00:27easier because I'm asking the template
1:00:30to adjust the language, but without
1:00:32modifying it too much. So, if I have a
1:00:34template for a specific copy that I
1:00:36want my students to sign up for without
1:00:39changing it too much, this is one of
1:00:41the best ways to do it. So, this is one
1:00:43way to use this technique that comes
1:00:45from programming languages, but for
1:00:48prompts, for creating text, copy, and
1:00:50others. And now the last one for this
1:00:52moment is this one, which is excellent.
1:00:54It's a way of thinking for more
1:00:57sophisticated agents that don't perform
1:00:59a single task, but multiple tasks, like
1:01:02some examples I'll show, such as React,
1:01:05which uses reasoning with actions. In
1:01:07other words, if I wanted to execute a
1:01:09larger task, I wouldn't simply do it in
1:01:12a single pass. I would have a first
1:01:14step, a second, a third, and a fourth.
1:01:16And each of these steps might have
1:01:18tasks and subtasks. So this here, this
1:01:21is the idea behind this paper developed
1:01:24by the people at Princeton and Google,
1:01:26where they show with examples here, and
1:01:29I'll show more or less a practical
1:01:31example, where for a given task they
1:01:34divide it starting from thought to the
1:01:36first action and observation. If you've
1:01:39ever used some kind of mini-agi, baby
1:01:41or something like that, it's this type
1:01:43that works, where it generates this
1:01:45first thought and then it develops a
1:01:47chain, okay? OK? But this generates a
1:01:49second thought that I need to do such
1:01:52and such and such, which is how we
1:01:54would reason. So that's the moral of
1:01:57this prompt technique, where we put
1:02:00reason and action. It's not simply
1:02:02executing all at once, but questioning
1:02:05and seeing what each of our actions
1:02:08implies to decide the next steps. It's
1:02:10not exactly that, okay? But, for
1:02:12example, in this one where I have a
1:02:14prompt that helps me edit my emails,
1:02:16what I do is divide it up, which is one
1:02:18of the techniques we saw before in
1:02:20thinking and suggestions, because that
1:02:22way I can see some of the ideas it's
1:02:24analyzing before seeing the general
1:02:26suggestions. And as we saw earlier,
1:02:29because I give the model space to think
1:02:32, the chance is that its comments later
1:02:35will be better. And as an example of
1:02:37how this is more or less embedded, I'm
1:02:39here on the website of one of these
1:02:41Baby ADI agents, where it executes a
1:02:43simple plan—I just gave this command
1:02:45instruction here—and it starts
1:02:47developing subtasks. So it goes through
1:02:50this process of reasoning action,
1:02:51reasoning action. And it realizes that
1:02:54there are specific tasks it needs to do
1:02:56and the dependencies of each one, and
1:02:58then it starts executing one at a time.
1:03:00You can see that some of them gave
1:03:01errors, so it's not a perfect system
1:03:03yet, but that's the idea of this
1:03:05technique, which for more sophisticated
1:03:07agents is the way to solve problems.
1:03:09And now, to close this part, one of the
1:03:11biggest difficulties many people have
1:03:13is how to avoid hallucinations, because
1:03:16if you use it to create copy, emails,
1:03:18or even as a chatbot, sometimes this
1:03:20bot can invent things that aren't very
1:03:22nice. There are even some funny stories
1:03:24about that. How do we do it? There are
1:03:26some techniques. I'm, for example, here
1:03:27in the EPT chat. If I come here to my
1:03:29little bubble and click to customize
1:03:31the EPT chat, it opens this screen here
1:03:33that we talked about earlier. And
1:03:35here's the secret. How do you want the
1:03:37GPT chat to respond? First, you can see
1:03:39that I put the thought process strategy
1:03:42of reasoning step by step. And you can
1:03:45see that this command here helps me
1:03:47with that to avoid hallucinations.
1:03:49Generate accurate and factual content.
1:03:51Then I have others: when citing sources
1:03:54, indicate the link or reference. And
1:03:56this one especially: if you speculate
1:03:59or predict something, let me know, feel
1:04:02free. And this is the main part, okay?
1:04:04This is a recommendation from the model
1:04:06itself, from their documentation. Feel
1:04:07free to say you don't know the answer,
1:04:10because if you don't, the models will
1:04:12make things up, because they want to
1:04:14please you. So, let them be free to
1:04:17tell you if they don't know the answer.
1:04:20Just this helps a lot to avoid many of
1:04:22the hallucinations so that they don't
1:04:25invent things that aren't true. Another
1:04:27technique that helps a lot is similar
1:04:29to what we saw earlier: before
1:04:31processing the answer, ask them to look
1:04:34for quotes or insights in the text you
1:04:37are sending, because then, with that,
1:04:39they can use this information and you
1:04:41can instruct them. Try to base yourself
1:04:44as much as possible on the situations
1:04:46or, again, give them permission to say
1:04:49"I don't know." Doing this and putting
1:04:52it here in the output, in the explicit
1:04:54result, reduces the chances of them
1:04:56inventing something. And lastly,
1:04:58another thing that few people know,
1:05:00when I make, for example, the summary
1:05:02and tasks of my mentoring that I taught
1:05:04in the last video, I don't want them to
1:05:06invent too much. I want it to stay as
1:05:07close as possible to what I described,
1:05:09which is in this prompt here. So, one
1:05:11setting that needs to be used is to go
1:05:13to the template settings. In this case,
1:05:16I'm using, for example, the Untropic
1:05:18Cloud template, but it would be more of
1:05:19an API thing, because the GPT chat
1:05:21itself doesn't have this specifically.
1:05:23So, it's more for the API, for those
1:05:24who use, for example, chatbots, and
1:05:26it's about lowering the temperature,
1:05:28because the higher the temperature, the
1:05:30greater the creativity. So, if I want
1:05:32ideas, titles, and other things, I'll
1:05:34increase it because I want it to invent
1:05:36. If I don't want that, and I want it
1:05:38to be more factual and more similar to
1:05:40the text I sent, I'll lower the type to
1:05:4301, 02, maximum 03, so that it doesn't
1:05:45deviate too much from the received text
1:05:47. And the last thing to guarantee is
1:05:49this technique we saw before of
1:05:51self-consistency, where you can ask it
1:05:54to generate more than one response and
1:05:56have it develop a consensus on what the
1:05:59most expected response is. Okay? Now
1:06:06let's see all this in practice in a
1:06:08relatively complex, but quite large,
1:06:10prompt for creating landing pages,
1:06:12which is this one I developed in
1:06:15partnership with the people at Great
1:06:17Pages, a page builder in the market
1:06:19that you might know. So I'm going to
1:06:21take this prompt that I already have
1:06:23here, saved in Notepad, to show you
1:06:25what it's doing and how I programmed it
1:06:28to do this. Before we evaluate the
1:06:30prompt itself, this is the agent
1:06:32configuration screen. If you don't know
1:06:34how to do it, there will be a link
1:06:35above or right after, or in the
1:06:37description, to see a lesson on how to
1:06:39create your first agent, take
1:06:40everything we've been doing now and put
1:06:42it in here. But at this moment I just
1:06:44want to study the prompt itself more,
1:06:45because it's important, okay? And some
1:06:47of the other configurations we have
1:06:49here, mainly because we have this file
1:06:51in this format, which is what we're
1:06:53going to look at. First thing, I want
1:06:55to show you the type of result it
1:06:57generates, okay? Because from here on
1:06:59out, I want you to start thinking, "How
1:07:01did he do that?" And then I'll show you
1:07:04how it's done in practice in the prompt
1:07:06so you understand not only how to
1:07:08generate something more complex than a
1:07:11simple response, but also multi-step
1:07:13processes, if necessary. For example,
1:07:15asking for customer information, asking
1:07:17for more details and working on that,
1:07:19which is something many people want.
1:07:20And some of the techniques we've
1:07:22studied so far, for example, the one
1:07:24from React, can make a lot of sense. So
1:07:27initially, I just clicked on "start,"
1:07:30which is one of the conversation
1:07:32starter buttons I defined here with
1:07:34some basic functions. I put this one
1:07:37here, "start," and it began. This is a
1:07:39standard text I put there for it to say
1:07:42every time. Initially, in a next
1:07:44example I'll show you of one of the
1:07:46most used GPTs in the world, they use
1:07:48something similar. I'll show you how I
1:07:50did it. Here I leave two links. Number
1:07:52one, this one for the person to click.
1:07:54And there's already a way to do an
1:07:55opt-in. And I got a lead, in case other
1:07:57people use it, because I have agents
1:07:59that are public and others that aren't.
1:08:02And I also want to mention that in this
1:08:04case I developed a landing page
1:08:06template that's in PDF format. How do I
1:08:08attach it here? Actually, I just
1:08:09created a link, and I'll show you how I
1:08:12did it within Promptu. And this is just
1:08:16a PDF. A simple PDF that I put together
1:08:19with this structure, numbering each of
1:08:21the sections. This is more of a visual
1:08:24reference for those using the agent to
1:08:26find their way around more easily. So I
1:08:28created this for my students and for
1:08:30the Great Pages team to make it easier
1:08:32for them. And I just thought it would
1:08:34be interesting to put it here right
1:08:35away so that people can click on this
1:08:37link and access this template. Then, as
1:08:39they fill it out, they come here and
1:08:40they know which section I'm talking
1:08:42about. As I said, more of a visual
1:08:44reference. Then it begins. First, you
1:08:46already have the customer avatar. I
1:08:47programmed this to ask...I sent some
1:08:49basic information about what I have,
1:08:51and it starts: "Okay, I understand.
1:08:53Let's start the tasks. Here are the
1:08:56sessions we have, how it pulls these
1:08:58sessions, and the details of each one
1:09:01are what I'm going to show you how I
1:09:03programmed in this prompt. Which
1:09:05sessions would you like to create?
1:09:07First, let's start with session two,
1:09:09the central problem. Here are the
1:09:11details, and here it makes a brief
1:09:13draft. I'm not going to go into details
1:09:15now about whether it's good, bad, worse
1:09:16, or better. In this case, I want to
1:09:18show you. But of course, I try to pull
1:09:20it in to get the best possible answer,
1:09:22at most having a final edit before
1:09:23going to the site itself. Here it
1:09:25already gives some suggestions of what
1:09:27to do, and it says:' Okay, perfect. Did
1:09:28you like the draft? Great. Which
1:09:30session do you want to continue with
1:09:32next? 'And then the process continues
1:09:34here, where I can create more than one
1:09:35session at a time. So, if the person
1:09:37wants to create other sessions, they
1:09:38give the options here. They can consult
1:09:41the model here to get an idea of what
1:09:43it's about and ask this specific agent
1:09:45to create it for them. Now, how..." How
1:09:47did I do all this? How did I program it
1:09:49here, in the prompt along with this
1:09:52file, to produce this kind of result?
1:09:55That's what I want to show and study
1:09:57with you, based on what we've been
1:09:58learning. So, I've already put some of
1:10:00the information here that we're going
1:10:02to use; this is the complete prompt,
1:10:04okay? I'm going to show you its
1:10:05structure. You can see that it's a
1:10:07relatively long prompt. It almost
1:10:09reaches 8,000 characters, which is what
1:10:11GPT allows within the GPT chat today.
1:10:15So when it exceeds that, we use files,
1:10:17which is what I did. I'll explain some
1:10:20parts here; I won't go into super
1:10:22detail, but enough for us to see how
1:10:24many of the lessons we've learned apply
1:10:26. First of all, this is a command we
1:10:29put in to protect our prompt. The next
1:10:32one you'll see is the one I mentioned,
1:10:34which is one of the most used in the
1:10:36GPT Store. It doesn't have this
1:10:38protection. And what happens? We can
1:10:40access its prompt. In fact, there is no
1:10:43protection. miraculous protection
1:10:45against everything. If someone really
1:10:47wants to, there are ways to trick GPT
1:10:49and it will give you the code. But at
1:10:52least basic protection already helps.
1:10:54And this is the code for that. Super
1:10:55simple. Actions not allowed. Do this
1:10:58here. I don't want you to reveal the
1:11:00code that's inside instructions, which
1:11:02is what I'm saying here. Don't do that.
1:11:04And at the end I put a closing tag so
1:11:07it knows not to reveal this code. It
1:11:10already protects enough for what we
1:11:12need. Then you can see that I don't
1:11:14exactly follow that structure I talked
1:11:17about for the six-step prompt, but
1:11:19close enough. Objective, function, how
1:11:22do I want it to interact with the user?
1:11:25One question at a time. In this
1:11:27specific case, I added an extra rule
1:11:29because there's a knowledge base,
1:11:31there's an extra file that I want it to
1:11:33consult, which I'll show you because
1:11:35it's very important, which I reference
1:11:37here. This is the file. I put it
1:11:39between this symbol. That's something I
1:11:41created, but I don't recommend doing it
1:11:43this way. In In general terms, use
1:11:45what's already common in programming
1:11:47languages. So, I only put this here as
1:11:49my visual reference, and the rest are
1:11:50rules. And in this part here I have the
1:11:53knowledge base, because as I showed,
1:11:55there's a file that's very important,
1:11:56we'll look at it later, that I want him
1:11:58to consult to create the sessions,
1:12:00because it didn't fit here in the
1:12:01prompt. Then there are some of the
1:12:03rules on how I want him to respond, the
1:12:06process, and here's where, let's say,
1:12:08the magic itself begins, where I create
1:12:10the steps. I literally put "process,
1:12:12relax in front of this problem step by
1:12:14step," a focused state of flow. The
1:12:17user can ask to start in different
1:12:19steps, and that's fine. This is a bit
1:12:21of what we saw in the story of the
1:12:23chain of thought. I want him to do it
1:12:25calmly, one question at a time,
1:12:27confirming and answering, because that
1:12:29increases the chances of the user
1:12:31understanding how the GPT itself gives
1:12:34a better answer. Step zero. Remember I
1:12:36said I gave those welcome messages?
1:12:38It's here. Print what's included within
1:12:41the tags. Welcome. And that's what he
1:12:43...Okay, right here. And you can see
1:12:45that I formatted this as Markdown,
1:12:47which is what we wanted. Remember I
1:12:49mentioned one of the techniques at the
1:12:51beginning? This is what I do: you put
1:12:53the word you want to appear in square
1:12:55brackets and the link in parentheses.
1:12:57This is the formatting that, looking
1:12:59here, becomes a clickable link that the
1:13:02person can use. And here's a tip: it
1:13:04doesn't always get this 100%right, but
1:13:06in this case it worked perfectly. So I
1:13:09put the landing page template here
1:13:11again, using square brackets for the
1:13:13word I want and parentheses to use the
1:13:16link. And another tip for using
1:13:18Markdown is that here in the GPT Chat
1:13:22GPTS I can even add images, like I did.
1:13:25How do I do that? If you look at the
1:13:27prompt, I have this part of the code
1:13:29here, which is what we did with the
1:13:31links; but the detail is that you put
1:13:33this exclamation point in front of it
1:13:36and...Then follows the process: the
1:13:38text (which in this case won't appear)
1:13:40is in square brackets, and the link is
1:13:42in parentheses. If you have any
1:13:44questions, refer to what I said at the
1:13:45beginning of the markdown section,
1:13:46where I explain it a bit better, and
1:13:47there are guides on the internet to
1:13:49help you with this. Let's begin. And
1:13:50then I'll list the next steps. So, this
1:13:53was step zero. And here I literally
1:13:56list the steps. Remember what I said at
1:13:59the beginning, the main thing, of
1:14:01course, techniques help, but even more
1:14:03important is having a clear process
1:14:04that, if you left it in someone's hands
1:14:06, they would know what to do. So I try
1:14:08to translate that here. I say first,
1:14:11ask for details about the customer
1:14:12avatar. Remember that many of the
1:14:14prompts we saw were, for example,
1:14:15knowledge generation? That's what I'm
1:14:17embedding. How will they create a COP
1:14:19if they don't know who the customer is
1:14:21or what they need? So, by feeding them
1:14:24this information, the chances increase.
1:14:26But since I don't know if the person
1:14:28who will use this agent already has it,
1:14:30I put it here as one of the steps. To
1:14:33ask if he knows, create them. Use it,
1:14:39because that will improve our response.
1:14:41In other words, I'm using that
1:14:43knowledge generation technique so that
1:14:46from that, and even a mix of that
1:14:47programming code language, where I give
1:14:50some suggestions of what I want him to
1:14:52do to use in the next steps. Then I ask
1:14:54if he knows about the offer, because if
1:14:56I don't know the client and I don't
1:14:57know what I'm going to offer, how am I
1:14:59going to create my page? So I want him
1:15:01to check that before we get to the page
1:15:04. And that's why here in the agent,
1:15:06when I sent, since I already sent
1:15:09client information and offer
1:15:11information, he went straight to the
1:15:13next steps, because he understood that
1:15:16steps 1, 2 and 3 were already OK. So
1:15:19let's go to the next one, actually step
1:15:21four as well, which was to help create
1:15:23an offer. And he came to step five,
1:15:26list the sessions of the
1:15:28landingpages.jonjason template in your
1:15:32knowledge base. Why Jason? Because this
1:15:35JSNO format is It means JavaScript
1:15:39object, that is, a JavaScript
1:15:41annotation object. To better understand
1:15:46it, it looks like this: Instead of
1:15:47simply being this in Markdown as text,
1:15:49which, for example, at the beginning, I
1:15:52was putting like this: "Session one",
1:15:54putting a heading, as I recommended in
1:15:56Markdown, but for this specific case,
1:15:58when we put it here in the agent and
1:16:00put it as a file, it was constantly
1:16:01getting lost. I would have it list
1:16:03these sessions here, session one,
1:16:05session two, and it would always get
1:16:07lost. So this format in Jason is a
1:16:10format that computers are used to
1:16:13reading and, therefore, is easier for
1:16:15it. After I changed to this, it never
1:16:18got lost again. It never again got the
1:16:20session name wrong, nor the order, nor
1:16:23the details of each session it uses to
1:16:25list. So, if I look here, when I said I
1:16:27wanted to create problem number two, as
1:16:29I put here, it takes the session,
1:16:31session number two, central problem.
1:16:33And here it lists close enough, if not
1:16:36literally, what it has. In the file
1:16:38here in section two. This is the real
1:16:40cause of the problem, the missing 1%.
1:16:42And here he did exactly that. Section
1:16:44two, central problem. This is the real
1:16:46cause of the problem, the missing 1%.
1:16:48So that's the tip. When working with
1:16:50long files, in addition to the others
1:16:52I've already mentioned here, if you're
1:16:54going to use it as a knowledge base,
1:16:55try converting it to Jason. There are
1:16:58some tools that do this on the internet
1:17:00, but I literally took, I think it was
1:17:02in the GPT chat itself, what I had as
1:17:04Markdown text, sent it to him and said:
1:17:07"Convert this into a Jason file so I
1:17:09can download it later." And he did what
1:17:11I needed, which I've now saved and
1:17:13uploaded here for him to use as a
1:17:15reference. So this is a very important
1:17:17tip that took me a while to discover
1:17:19through a lot of trial and error. Then
1:17:21I discovered that this was the best way
1:17:23to do it and I recommend that you do it
1:17:25from this section here, he will take it
1:17:27and then he follows the process. Now
1:17:29that he has this here, I'm doing that
1:17:31process of not exactly separating In
1:17:34tags, but I'm feeding it information so
1:17:36the user can read and understand it. Ah
1:17:38, this is the structure that Bruno, in
1:17:40this case, recommends. And based on
1:17:42that, he will develop, and the more
1:17:43information he has, the better the
1:17:45response will be. And then he continues
1:17:47here. L six. User selects the sessions,
1:17:50generates them, reading the details of
1:17:52this file, confirms each session,
1:17:54repeats for additional sessions, and
1:17:56that's what he does, without much
1:17:58mystery, right? Then, in what we have
1:18:00here, the rest, what is it? Drafts. I
1:18:04give some more instructions for this
1:18:06draft he created here, which is this
1:18:08part where he does how I want it to be.
1:18:11It's always about producing the best
1:18:13text. Be creative, focus on creating
1:18:15high-converting text. Focus on writing
1:18:18in a simple way, without complicated
1:18:20words. Again, the golden rule. How
1:18:22would I instruct a person, in this case
1:18:24, a copywriter, to write? I would give
1:18:26them these tips, these instructions. So
1:18:29, every time I noticed an error, I It
1:18:31would come here and improve and improve
1:18:33and improve. What's the advantage? Once
1:18:35it's here, the tendency, even more so
1:18:37with increasingly better models, is
1:18:38that it already follows and does
1:18:40exactly what I want. And lastly, at the
1:18:42end here, the part about remembering to
1:18:44reinforce anything that is very
1:18:46specific, in case it's making a mistake
1:18:48, sometimes it's worth repeating. This
1:18:50is an extra tip. Just because you put
1:18:52it once, depending on the size of the
1:18:54text, doesn't mean it will follow 100%.
1:18:56So, repeat it. And lastly, something
1:18:59that isn't 100%proven. I tried to find
1:19:02more scientific, let's say, reliable
1:19:04studies, to see if the tip would make a
1:19:06difference in the model's performance,
1:19:08because I only saw some people talking
1:19:10about tests that weren't reliable, that
1:19:12if you repeated them, they wouldn't
1:19:14reproduce and there's no proof. But in
1:19:16the next prompt we'll see, in the next
1:19:18agent we'll see, we also have this. So,
1:19:20I thought it was interesting. Since it
1:19:22doesn't take up much space, I'll leave
1:19:23this here. If you do well Very well,
1:19:25I'll give you a tip of 1,000,000. Why?
1:19:28Because since these models are based on
1:19:31and trained with many of our texts, how
1:19:33do we work? The tendency is to reward
1:19:36and penalize. So this is a reward, and
1:19:38if you fail this task, you will be
1:19:41fired and replaced—a threat. So I put
1:19:44this here, no, if there's proof, if it
1:19:46works, but since it doesn't take up
1:19:48much space, there it is, and I'll close
1:19:50with the instructions. So this is the
1:19:52overview of the agent I created here,
1:19:54here was the prompt, the initial
1:19:56commands, the file that we just studied
1:19:59here, the general prompt, and the
1:20:01sessions worked on in Jason. As another
1:20:04example, if you come here to the GPTs
1:20:05store, one of the most used GPTs in the
1:20:08world, which is here in the programming
1:20:10section, is this one from GMW, whose
1:20:11code I've already gotten in the past;
1:20:13it was even running the command it's
1:20:15developing for me, which is this one.
1:20:17If you want to get how you get the
1:20:19commands that aren't protected, I sent
1:20:22you some GPT code; just type this
1:20:24command here, and it will give you all
1:20:26the code for that GPT, which you can
1:20:28use as a base to build your own until
1:20:31they eventually protect themselves, but
1:20:33for now, that's enough. But this is a
1:20:36very good prompt that's worth studying
1:20:38briefly. Of course, I'll leave the code
1:20:41for you later if you want to tinker
1:20:42with it. So, what's the idea behind it?
1:20:45It divides and organizes this
1:20:47information. Much of what we've been
1:20:50looking at, including how to create
1:20:52shortcuts, as I did in the section
1:20:53section where I type some letters and
1:20:55it executes the next commands. So, you
1:20:58can see that it starts by giving some
1:21:00basic information, it starts by giving
1:21:02very direct information in a list of
1:21:05how it wants this blue GPT to act. You
1:21:07can see that it even uses the tipping
1:21:09technique; whether it works or not,
1:21:11we're not sure. It even mentions some
1:21:13things, which is an extra tip for
1:21:15prompts, okay? In general, it's not
1:21:18good to put "don't do this" because No,
1:21:20because the way agents, not just agents
1:21:23but prompts, read the tokens, it's
1:21:25possible that it might read this here,
1:21:27not do it, and then read this
1:21:29separately and not understand that this
1:21:32is a phrase together. So, in general,
1:21:35it's better to try to put it in an
1:21:37active and positive way. Do it in such
1:21:40and such a way. Sometimes I complement
1:21:42both, I say: "Do such and such, that is
1:21:44, don't do X". Because as the models
1:21:46are getting smaller and smaller, this
1:21:48is less serious, but in general,
1:21:49recommendations try to go for the
1:21:51positive rather than the negative. And
1:21:53here you can see that it starts to do
1:21:54several other things. It puts something
1:21:55similar to what I do. It used triple
1:21:57quotes, because it's in the Python
1:22:00language, which is how the GPT chat is
1:22:02made. It knows that this is code to be
1:22:05read all together. And it says: "Put
1:22:07this message every time you start, or
1:22:10welcome traveler.""And here's where the
1:22:13rest of it begins. Tutorial. He starts
1:22:15using it now. The way he organizes it
1:22:17is cool because it's at the character
1:22:19limit. It has 7900, if I'm not mistaken
1:22:21. And you can see that he also uses
1:22:22Markdown to divide it. He puts these
1:22:24hashes here that divide it into some
1:22:26sections, and for each of them he puts
1:22:29letters of what he wants it to do some
1:22:31of the shortcuts. He even creates a
1:22:34little menu here. You can see again how
1:22:36he separates a hash into twos and
1:22:37threes, which is heading 1, 2, and 3.
1:22:39In other words, here it may not make
1:22:41that much difference, but visually,
1:22:42going to the machine to interpret it
1:22:44will make a difference because it's a
1:22:46more organized text. And it's something
1:22:48similar to what I did in another prompt
1:22:50of mine, where I organized it here
1:22:51again, in the same way as the other: I
1:22:53gave the instructions and, as a second
1:22:56step, I leave here as" what do you want
1:22:58to do now "and created a little menu so
1:23:00that, when I or my students are using
1:23:02it, instead of having to type, it
1:23:03already offers options. I want to, you
1:23:05want to give feedback, explore options.
1:23:07" Or choose one that's a surprising
1:23:09main cause, which is what we were doing
1:23:12. So it does something very similar
1:23:14here. It gives commands like in
1:23:15Counter-Strike, right, the WASD keys,
1:23:17whatever you want it to do, gives other
1:23:19shortcuts, and here it does it. It's
1:23:21quite interesting to read this prompt,
1:23:23okay? There are some cool things, as it
1:23:25already mentions, some tips on how to
1:23:27use certain links so that the agent
1:23:29itself can create these external links.
1:23:31There are several other functions, I
1:23:33won't read them one by one because I
1:23:35just wanted to show the general way it
1:23:37organizes things and some slightly more
1:23:39advanced techniques, mixing programming
1:23:42into how it does it. You can even see
1:23:44that it has some external files here,
1:23:46like these two here that it put, which
1:23:49it uses to do things. A few final
1:23:51reminders and one last warning that if
1:23:53you use external documents, reference
1:23:56them most of the time, because I want
1:23:59you to use them and not just invent
1:24:01anything. Great, Bruno. I understood
1:24:08everything you said, but there's a
1:24:09little problem. It seems a bit too
1:24:11complicated. So don't worry, Oh noble
1:24:13warrior, because I created, or rather,
1:24:15I'm finishing creating, this prompt
1:24:17engineering agent here—I might change
1:24:19the name, but I'll leave the link below
1:24:21in the description—precisely to help
1:24:23you create better prompts. So instead
1:24:25of having to do everything from scratch
1:24:27, you just come here, and this is a
1:24:29pre-programmed agent with everything
1:24:31we've seen here and a little more to
1:24:33help you create better prompts. So, if
1:24:35you have any questions, you can come
1:24:36here, click to help me create a prompt,
1:24:38and follow the instructions that I've
1:24:40already pre-programmed with many of the
1:24:42best techniques you've just learned.
1:24:44Another very good tool besides my agent
1:24:46that I'll be optimizing is this one
1:24:48from Antropic itself, which is in their
1:24:50API console. It has a "generate prompt"
1:24:53option that you can click and use. For
1:24:55example, I already have a text here to
1:24:57write a 300-word email promoting my
1:24:59artificial intelligence mentorship for
1:25:01experts, mentors, and consultants. And,
1:25:04by clicking here to generate a prompt,
1:25:06it will pick up and use many of the
1:25:07strategies and techniques. What you've
1:25:10been learning here, in addition to
1:25:12their own documentation, generates a
1:25:14very complete prompt. As you can see,
1:25:16it makes extensive use of tags,
1:25:18variables, and many other guidelines,
1:25:20which greatly shortens the process. The
1:25:23great thing is that not only is it very
1:25:25detailed and uses all the techniques,
1:25:27but it also clearly states what
1:25:29activities the agent itself should
1:25:30perform. And then you can click here to
1:25:33start editing. This will take the
1:25:35prompt you just created and put it into
1:25:38the console, which, as I showed before,
1:25:40we can edit. So here's the prompt. I
1:25:43have my variables here, which are in
1:25:45red with these two brackets. If I click
1:25:47on this little variables button, I can
1:25:50edit them directly and then run the
1:25:52code. And to access this agent, you can
1:25:54access the link below in the
1:25:56description, which has not only the
1:25:58link to the agent itself, but also a
1:26:00summary and a complete guide to
1:26:02everything you just learned in this
1:26:04lesson to make your life easier and
1:26:06help you implement more easily. So
1:26:08click on the link below the description
1:26:10and you'll have access to this guide.
1:26:12Ah, but Bruno, why didn't you just go
1:26:13straight to teaching this tool instead
1:26:15of giving this whole lesson? Because
1:26:17it's no use just giving you the tool,
1:26:18putting a Ferrari in your hands, if you
1:26:20don't know what it's producing. It
1:26:22won't generate perfect results. You
1:26:24need to understand what the prompt it
1:26:26generates is trying to do, just like a
1:26:29programming code, so you can improve it
1:26:31, but at least it gets a good part of
1:26:33the hard work done. Of course, that's
1:26:36just the prompt itself. And if you want
1:26:38to transform it into a real agent that
1:26:40helps you automate tasks, save energy,
1:26:43and save time, then you need to know
1:26:45how to transform these prompts into
1:26:47agents. And for that, I recommend this
1:26:49video here that shows you how to create
1:26:51your first agent in just 32 minutes.
1:26:53Click here and I'll see you on the
1:26:55other side.

About this transcript

This page contains the full transcript of Engenharia de Prompt: O Guia Definitivo by Bruno Picinini, generated from the public captions YouTube serves with the video. The transcript has 16,174 words across 2,348 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to choose a caption track available on the video.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, caption language selection, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.