So if you've been using the latest AI models,
maybe chat GPT -5, you might have noticed something
a bit weird. Yeah, like you know you're using
this incredibly powerful tool, right? State of
the art. Exactly. But the results, they can be
all over the place. Sometimes amazing, sometimes
not so much. Right. You get this brilliant piece
of analysis one minute, and then next the answer
feels kind of lazy, almost worse than the older
model sometimes. It's confusing, isn't it? You're
paying for the premium model expecting top quality
every time, but it dips. So why is this super
smart AI acting well? Kind of inconsistent. It's
a fair question, and it feels backwards. But
the issue isn't really the AI model itself. It
is powerful. OK. The problem comes from a couple
of big changes OpenAI made in how the whole system
worked. Basically, the way we used to write prompts,
it's tripping up this new setup. Oh, OK. So our
old habits are the problem. Let's dig into that,
then. Yeah. The goal today is really to give
you, the listener, a clear strategy to get back
to those consistently high quality results. Definitely.
We're going to unpack these two main changes.
First, this invisible router thing, and also
how the AI now follows instructions very strictly.
And then we'll jump into five specific tips.
We'll start simple with easy nudges and build
up to something we call the perfection loop.
It's a bit more effort, but wow, the results.
All right, let's get into it. Segment one. Yeah.
Why the old ways are failing. This invisible
router. What's that about? I remember you used
to be able to pick different models. You did,
yeah. You could choose GPT -5, maybe a thinking
version. You felt like you had control. Right.
Now the interface seems simpler. But behind the
curtain, when you send your prompt, it hits this
invisible router first. Think of it like an automatic
traffic cop for your request. A traffic cop?
But if I'm paying for the best model, why does
it need routing? Shouldn't it just go to the
best one? That's the logical thought, yeah. But
here's the catch, and where the user frustration
often comes in, those really powerful models,
they take more computer power, they cost more
for OpenAI to run. Ah, so the router is maybe
optimizing for cost. You got it. It's often engineered
to find the most efficient path, which usually
means the fastest and cheapest AI model available
that might be able to answer the query. So it's
defaulting to good enough to save resources,
even if I wanted great. Precisely. And that good
enough model gives you those, well, less impressive
inconsistent answers sometimes. That's the hidden
mechanical reason for the quality dips. OK, that
makes a lot of sense, actually. So that's the
router. What about the other big shift, the training?
Right, the second piece is how it's trained.
Chat GPT -5 got a lot of training focused on
serving AI agents. These are programs, basically,
that need instructions followed perfectly. No
mistakes, no guessing. OK, so it got really good
at following orders exactly. Super good. But
the flip side for a regular user like you or
me, if your prompt is a bit vague or you leave
things out, It's much worse now at trying to
figure out what you meant. It won't fill in the
gaps like the older ones might have. Nope. It
sticks rigidly to what you typed. No implied
instructions. That sounds demanding. It can be.
And honestly, I still mess this up sometimes.
You know, I rush a prompt, make it too simple.
Happens to the best of us. Right. Just last week,
I asked for a quick summary and it gave me this
long definition of terms I obviously already
knew. Slight chuckle. Took me a few tries to
get it right. It catches you out if you're not
precise. OK, so the router pushes towards cheapness
and the AI demands exact instructions. So the
big question then, how do we make the router
pick the smart expensive model when we need it.
Ah, well, that's where our specific phrasing
comes in. We have to signal it. Leading us nicely
into the quick wins. Tip one. Tip one. Use router
nudge phrases. This is probably the easiest thing
you can do. Seriously low effort. OK. You just
add a specific little phrase right at the end
of your prompt. It's like a little flag for the
router that says, hey, stop. This one needs actual
thinking power. What are these magic words then?
What tells the router to wake up the big guns?
The ones that work consistently are phrases like,
think carefully about this, or think deeply about
this. Sometimes think hard about this works,
too. Hmm. OK. Simple enough. Yeah. Using one
of those basically forces the router to send
your request to a more capable model, avoiding
that quick, cheap default route we talked about.
I can see that being useful. Like if I'm asking
it to, say, outline pros and cons for a big decision,
adding, think deeply about this, would probably
get me a much better, more nuanced answer than
just asking the question straight. Exactly. You
should definitely use it for anything important.
Business plans, you know, data analysis, drafting
a critical email, things where quality really
matters. Oh, and a quick heads up, don't use
emotional language. Saying things like, this
is really important to me doesn't seem to work.
Right. It's a machine. It needs commands, not
feelings. Precisely. Keep it clear. Keep it command
-like. OK, so that's nudging the router. What
about the output itself? Tip 2 is about length,
right? Yeah, controlling the output length. Because
the router also kind of defaults to shorter answers,
again, to save processing time. So we need to
be explicit about how much text we actually want.
Makes sense. So for short stuff, like just the
key points. Right. For a short output, you'd
say something like, summarize the main points
in under 100 words. Perfect for maybe a quick
project update email or you know a tweet Okay,
and if I need a bit more like the main points
plus some background That's your medium output
try asking it to explain this topic in about
three to five short paragraphs That works well
for explaining something like why your websites
click through rate dropped Maybe to your team
gives context and then the big stuff full reports
articles detailed full output be specific provide
a detailed and full analysis around 600, 800
words, or even more, like write a comprehensive
guide of about 1 ,200 words. That gets you the
full document. Numbers seem key here. Specific
word counts or paragraph counts. Absolutely.
And a little pro tip here, use a text expander
app. You can save these length commands like
summarize under 100 words and just type a short
code like S100 to insert the whole phrase. Saves
a ton of time. Nice. Okay, so we can nudge the
router and control the length, but what about
improving the actual prompt before we send it?
How do we make the prompt itself better? Great
question. That leads us to using a meta prompt.
We basically get the AI to help us write a better
prompt for itself. Okay, tip three, the meta
prompt optimizer. You're saying we can use the
AI to improve our instructions for the AI. Exactly.
It sounds a bit circular, maybe, but it works
incredibly well. Most people don't know OpenAI
has internal tools for this, but we can kind
of replicate it with a specific type of prompt.
A meta prompt. Yeah. Which is just a prompt about
prompting. Yep. You're telling the AI to act
like a prompt expert and fix your request. So
wait, we're asking the AI to critique our prompting
skills. Is that really necessary for, like, just
asking for a blog post idea? Well, maybe not
for every single query. But remember how strict
it is now? Write the exact instruction following.
By having it analyze your prompt first, you force
it to clarify everything. You guarantee the instructions
it finally acts on are super clear and detailed.
The command is usually something like, you are
an expert prompt engineer, analyze the weak points
of my original prompt below, and then rewrite
it to be much clearer and more effective. Hmm,
okay. I can see how that would force clarity.
Do you have an example? Sure, think about a vague
request. Write a blog post about working from
home effectively. Pretty standard prompt. Right.
But the meta -prompt process might turn that
into something much richer. The rewritten prompt
would likely define the AI's role, like you are
a productivity expert. Specify the target audience,
remote workers new to the concept. Outline the
required structure. Intro, three main tips with
examples, conclusion, and set the tone, encouraging
and practical. Wow, okay. That's way more specific.
The difference in output quality must be huge.
Night and day. That detailed prompt just gives
the AI so much more to work with accurately.
And if you start doing this meta -prompting regularly,
I guess your prompts naturally start looking
more structured. Which brings us to tip four.
the XML sandwich. Exactly. You'll notice those
improved prompts often use these angle brackets
like this tag or context. These look like XML
tags. OpenAI actually recommends this structure
internally. It helps organize complex instructions.
I like the analogy you used before thinking of
them like clearly labeled boxes. Instead of just
a messy paragraph of instructions, you're giving
it distinct blocks of information. Audience,
tone, goal. Precisely. It breaks it down logically.
The AI processes structured information really
well. Let's take an example. maybe asking for
a study plan. Right. A bad prompt is just, make
me an IELTS study plan, I need band 7. Vague.
A good structured prompt would use tags. Current
level band 6, current level, target score band,
7 .5 target score, week area speaking fluency,
complex grammar week areas, study time 10 hours
week study time. Much clearer. Each piece of
info is neatly packaged. And the result you get
back reflects that clarity. Instead of generic
advice, you'll likely get a detailed table, maybe
in markdown format, with specific activities
scheduled like practice part two cue cards, 30
minutes, or shadow native speaker audio, 20 minutes.
It becomes actionable. Yeah, that structure is
powerful, especially I imagine if you're setting
up custom instructions in chat GPT or building
your own custom GPTs. Definitely essential for
those. OK, so we've covered nudging, length,
optimizing the prompt itself with meta prompts
and structuring it with XML. This is all about
crafting the input. But how do we kind of guarantee
the output quality before we even see it? Ah,
that's the final piece. We embed quality control
inside the prompt itself. We make the AI check
its own work. Interesting. Let's take a quick
break and then dive into that final tip. Sounds
good. Mid -roll sponsor read. We'll be right
back after the break. All right, we're back.
We were just talking about making the AI guarantee
its own quality. What's the final tip? Tip five,
the perfection loop. Now this one takes a bit
more thought when you're writing the prompt,
but the payoff is potentially huge. Okay, the
perfection loop. How does it work? Instead of
just asking for the output and hoping it's good,
you first instruct the AI to define what a perfect
result would even look like for this specific
request. So you make it create its own checklist
first, based on my goals. That's clever. Exactly.
You tell it, okay, first... Figure out the criteria
for a perfect answer here. Maybe that's uniqueness,
clarity, engaging tone, fits the brand voice,
whatever is relevant. Then you tell it, draft
an answer. Then use your own checklist to grade
that draft. Keep refining it internally until
it scores a 10 out of 10. Only then show me the
final result. Whoa. So it does the drafting,
the critiquing, the editing all internally before
I even see anything. Yep. You essentially push
the quality control step. back onto the AI before
it delivers. You only get the polished version.
That's kind of amazing. So, for example, if I
needed a content strategy. You could tell it.
First, define the key elements of a successful
Q4 content strategy for a B2B SaaS company. Make
a checklist. Then, generate the strategy, review
it against your checklist, revise it until it's
perfect, and then show me the final 1010 strategy.
It assesses itself on things like scalability,
tone, alignment with goals. Or, for say, a YouTube
script. Create a checklist for an engaging tutorial
script. Hook, clear steps, visual cues, call
to action, friendly tone. Write the script, grade
it, rewrite it until perfect, then output. Wow,
just thinking about that. Imagine scaling that
kind of internal self -correction across, I don't
know, millions of tasks. It's not just prompting
anymore, that's like... managing an automated
quality process. It really shifts the dynamic,
doesn't it? It's best for those really complex,
high -stakes tasks. You know, writing entire
business plans, generating code that needs to
work first time, crafting really long, important
documents. Okay, so that's the fifth tip, the
perfection loop. Now, the big takeaway here seems
to be that these tips aren't really isolated
tricks. Not at all. The real power comes when
you start combining them. You layer them together
to create what we sometimes call a super prompt.
Right. Can we walk through building one, maybe
for that project proposal example you mentioned,
a fashion retail app? Sure. Perfect example.
So first we'd start with structure. Tip four,
we use those XML style tags. Okay, like company
context, dot company context, problem statement,
problem statement, and then maybe tags for each
required section of the proposal. Section one
introduction, section two solution, et cetera,
laying it all out clearly. Exactly. Then we add
tip two. Length control. We specify this proposal
should be detailed and complete around 5 ,000,
1 ,200 words. Give it a clear target. Got it.
Structure, then length. What's next? Now we bring
in the big one. Tip five, the perfection loop.
We'd add instructions like, before writing, define
an internal checklist for what makes a project
proposal highly persuasive and likely to be approved.
Grade your draft against this checklist. Refine
it until it achieves a 10 -10 internal score,
then present the final version. Okay, so structure,
length, internal quality control. Are we missing
anything? Just the final touch. Tip one, the
router nudge. Right at the very end of the entire
prompt we add, think very carefully about this.
Ah, the signal to use the powerful model. Yep,
so you see how it all stacks together. Structure
provides clarity, length sets boundaries, the
perfection loop ensures quality, and the nudge
phrase makes sure the right brain is doing the
work. That combination feels really robust. It
addresses both the router issue and the strict
instruction following. It gives the AI everything
it needs to succeed based on its new rules. OK,
so wrapping this all up, what's the main thing
people should take away from this deep dive?
I think the core idea is pretty straightforward.
The era of just typing vague one -sentence prompts
and hoping for the best. That's kind of over,
at least for consistently high quality with models
like GPT -5. Yes, the AI is more powerful. But
that power comes with these new conditions, the
invisible router, the need for absolute clarity.
So our approach has to adapt. It's less about
needing fancier tech and more about us being
better communicators. More structured, now we
ask. Exactly. Clear instructions, better organization.
You can start small, you know, just add those
router nudges and specify the length. That alone
makes a difference. Right. Easy wins first. Then
as you get comfortable, start playing with the
meta prompts, use the XML structure for complex
requests, and try out that perfection loop for
really crucial tasks. It feels like these techniques
aren't just about getting a better answer from
the AI. They're also about building better processes.
for working with the AI. That's a great way to
put it. It's about setting up an effective partnership.
You define the standards very clearly, and the
AI has the power to meet them precisely. So here's
a final thought to leave our listeners with,
something to mull over. We've talked about how
this AI is trained to follow exact commands perfectly
now. Super literally. What do you think happens
if you give it two instructions that are perfectly
clear, perfectly structured? but they directly
conflict with each other. What does forcing that
kind of logical paradox make the system prioritize?
Something to maybe experiment with. Ooh, that's
a fascinating question. What breaks first? Definitely
something to try. But for now, maybe just try
combining those first couple of tips, the nudge
and the length control, see what happens. Good
starting point. Thanks for breaking all this
down. My pleasure. Always fun talking about this
stuff.