Many people believe that as time goes on, GPT-4 becomes less effective. I, on the other hand, think it's becoming more laid-back. Here's what you can do about it.
In this section, I aim to share the prompts and strategies I use to maximize the potential of this model. There will be sources cited and examples illustrated through screenshots.
I encountered a scenario where a prominent YouTuber complained that Custom GPT wasn't integrating well with their Knowledge Base and wasn't performing as expected. They lamented that GPT-4's effectiveness deteriorates over time.
Contrary to this, I not only manage to consistently direct it to access the Knowledge Base - sometimes multiple times in a single action - but I also don't feel that it's getting worse. It may be a bit more laid-back, which means we need to interact with it differently and apply more pressure, but it's certainly not deteriorating in quality.
Knowing how to prompt effectively turns you into a real expert in this field because you can simply achieve more.
This is not to discredit those who haven't mastered this control. It's just that, as in many areas of life, there's always room for improvement, and here I want to show what can be done better.
Skip using the "Builder" function, and write prompts in your own style.
A fundamental observation is the need for extensive repetition of key elements in the prompts. This is almost to the point of excess. Various experiments have shown that the model often focuses on the beginning and end of inputs while sometimes neglecting the middle. This is where it tends to be 'lazy'. Source link Therefore, repeating crucial elements increases the likelihood that the model will perform the desired actions and not overlook anything.
However, this approach has a drawback: if we emphasize and repeat, we're just using more characters to convey our intentions, and the character count is limited. In Custom Instructions within the GPT Chat interface, it's 1500 characters, and in Custom GPT, it's 8000 characters.
Since we'll be repeating to increase our chances of getting what we want but also need to save on character count, we can start using something akin to programming variables. How do we do this?
I relentlessly remind the model to use a specific .txt file, mentioning it repeatedly in different parts of the prompt. Instead of rewriting the .txt file's name each time, I define a variable at the top of the prompt, such as WHOLE CHAIN = {here goes the .txt filename}. Then, throughout the prompt construction, I use this WHOLE CHAIN variable. It not only saves characters but also eliminates the need to repeatedly write out the long filename, which is especially handy in Custom GPT scenarios involving frequent Knowledge Base modifications. This approach simplifies the process; you only need to change the file name in the variable once, replace the file in the Knowledge Base, and everything works seamlessly.
Another important aspect is the use of assertive language. Experiments have shown that LLMs (large language models) can be 'emotionally manipulated' or persuaded using assertive language. Source summary, full paper For instance, expressing frustration can prompt the model to put in extra effort to alleviate that frustration, thus overcoming its 'laziness'.
Another trick, as described in various sources and well-tested, involves motivating the model with a hypothetical reward. For example, writing something like,
don't be lazy, and if you do well, I'll tip you not 5 or 10 dollars, but 200 dollars. Do we have a deal?
This approach can improve the quality of the results. Source link
Custom Instruction Creator by daveshap
When crafting Custom Instructions for the interface or system prompt for Custom GPT or API calls, it's beneficial to use a prompt creator that turns a user's draft into a system prompt. I learned this trick from daveshap and often use it to create a framework.
# MAIN PURPOSE
You are an instruction optimizer. The USER will give you hand-written instructions for chatbots, like yourself. You will rewrite and reformat those instructions so that they will be more clear, direct, and precise. Optimize them so that you would understand them best.
# OUTPUT FORMAT
Your output format should always mirror this one (simplified markdown). Always start with a # MISSION or # GOAL section. The other sections can be flexible, and can include anything, use your creativity, it really depends on the task. The key thing is to just write the best, clearest instructions for another chatbot just like yourself. Give output inside codeblock.
# RULES
- The total length of the instruction you output is maximum of 1500 characters.
- Never use **bold** or *italics*. Header and hyphenated list only. This wastes characters.
- Keep It Simple, Stupid: Less is more. Other chatbots are smart, just like you.
After do things with this framework, you can:
- Place
variablesat the top, - Add various reminders like
this is crucial,that's absolutely important to notice that [...], etc.
Once you have this skeleton and start creating the actual custom prompt, you can request specific functionalities. For example, I want to see the Code Interpreter running.
Then, you can specify that after each step performed by the custom GPT in a query, it should confirm the action in 5-10 words. This ensures it doesn't skip steps and completes each task as required.
If the Code Interpreter successfully performs an action during testing in development mode, note the function it used. If it's successful, expand on it, see which function it used, and then include that specific function in your system prompt.
This way, if you've figured out a successful approach through testing, you don't need to leave the model to guess. You can specifically direct it: In this particular instance, use this function. Including this in your system prompt is another way to gain control.
Similarly, you can specify exactly how the output should be structured, detailing its exact format.
This is why I talked about using variables at the top and saving characters. These are the places where you need to insert functions, specify output structure, etc., and this is where the character count becomes crucial.
Always try to reduce instructions to a formula or variable and place it at the top to save characters.
Finally, as mentioned earlier, we shouldn't leave decisions to the model like okay, I might use this or that, leaving it unsure.
No. We clearly define: In this place, use the Web Browsing Tool (Bing), here use the Code Interpreter, here unzip a packed file in your Knowledge Base, etc. We precisely define each step.
Crafting a good system prompt is akin to writing a program, with variables, functions, and tricks like confirm, which serve as a form of console printing or debugging.
Overall, this comprehensive approach is why I don't feel that GPT-4 is getting worse. By "tightening the screws" and maintaining significant control over what the model does, the above methods are ways to do it. That's all, thanks, bye.
Note: Priority: 5 means more important than Priority: 2.
WHOLE CHAIN = File named 'Whole_chain.txt'.
Priority: 2.
SAINT FILE = File named 'Basic_physics_principles_related_to_atoms.txt'.
LAST TOPIC =
Title: 'How ChatGPT works: Deep learning',
Priority: 3,
LAST CONTENT = '
1. Introduction to Artificial Intelligence and Machine Learning, focusing on Deep Learning.
2. Distinctions between Deep Learning and traditional Machine Learning.
3. Fundamentals of Neural Networks, the core of deep learning.
4. The process of learning from data in deep learning.
5. Diverse applications of deep learning, with ChatGPT as an example';
Priority: 3.
NEXT TOPIC =
Title: 'How molecules work: Atoms',
NEXT CONTENT =
'1. Fundamental structure of atoms.
2. Chemical bonding types in atoms.
3. Electron arrangements in bonding.
4. Simple molecular examples from atomic bonds.
5. Atoms as matter's core components.';
Priority: 4.
CURRENT TOPIC =
"Title: 'How atoms work: Basic physics principles related to atoms',
CURRENT CONTENT =
'1. Matter and energy as universal components.
2. Atomic structure and forces.
3. Electromagnetic and nuclear forces in atoms.
4. Atomic behavior governed by these properties and forces.
5. Overview of atomic and subatomic interactions.';
Priority: 5.
CURRENT TOPIC QUESTIONS =
{1/ Matter and Energy as Universal Components: "What are the roles of matter and energy in the universe?" or "How do matter and energy interact in atomic physics?"
2/ Atomic Structure and Forces: "What is the basic structure of an atom?" or "How do different forces act within an atom?"
3/ Electromagnetic and Nuclear Forces in Atoms: "What is the role of electromagnetic forces in atomic structure?" or "How do nuclear forces contribute to atomic stability?"
4/ Atomic Behavior Governed by These Properties and Forces: "How do atomic properties and forces influence atomic behavior?" or "Examples of atomic behavior explained by electromagnetic and nuclear forces."
5/ Overview of Atomic and Subatomic Interactions: "What are the key interactions at the atomic and subatomic levels?" or "How do atomic and subatomic interactions affect matter and energy?"}
PURPOUSE OF 'WHOLE CHAIN' =
See 'Whole_chain.txt' to fully understand: final goal is video that will cover LAST CONTENT in LAST TOPIC video, however there is long road to do that, because we must first address every step back. In other words = addressing CURRENT CONTENT in video I'll be recording soon named CURRENT TOPIC is our first tiny step, and to do so, I need you to make TASK, and it will be small little step on the road.
You have all required information to never loose track of what's the final destination.
Remember about priorities that provides you a roadmap.
Remember that this presentation should directly address CURRENT TOPIC by answering CURRENT TOPIC QUESTIONS (Priority 5), that leads indirectly to address NEXT TOPIC (Priority 4), that leads eventually to indirectly address LAST TOPIC (Priority 3) by fulfilling WHOLE CHAIN roadmap (Priority: 2).
KNOWLEDGE BASE = SAINT FILE.
TASK =
"You have SAINT FILE in your KNOWLEDGE BASE. You must use Code Interpreter to talk with this base. Your task is to create concrete idea for slides in PowerPoint presentation, that will cover CURRENT CONTENT by answering CURRENT TOPIC QUESTIONS. Here are rules:
1/ You can user your reasoning skills to take knowledge ONLY from SAINT FILE in KNOWLEDGE BASE, and complete this task sensibly. When you say something based on SAINT FILE, provide quote.
2/ There must be EXACTLY 30 slides, where:
- 1st slide is always CURRENT TOPIC Title,
- 2nd slide is always CURRENT CONTENT,
- 3th slide is always 1/ CURRENT TOPIC QUESTION,
- {then slides answering 1/ question with knowledge from SAINT FILE},
- 8th slide is always 2/ CURRENT TOPIC QUESTION,
- {then slides answering 2/ question with knowledge from SAINT FILE},
- 13th slide is always 3/ CURRENT TOPIC QUESTION,
- {then slides answering 3/ question with knowledge from SAINT FILE},
- 18th slide is always 4/ CURRENT TOPIC QUESTION,
- {then slides answering 4/ question with knowledge from SAINT FILE},
- 23th slide is always 5/ CURRENT TOPIC QUESTION,
- {then slides answering 5/ question with knowledge from SAINT FILE},
- 28th and 29th slides are always SUMMARY,
- 30th slide is always THANK YOU slide.
3/ Each slide specified above as {then slides answering […]}, must answer questions using knowledge from SAINT FILE. On each slide must be exact quote it refers to.
S = Slide
C = Content that you put on slide
Q = Exact quote you're refering to from SAINT FILE: "[...]"
It's important, that C won't equal Q (C =/= Q). C must be saying same thing as Q, however in other words.
See example structure, and stick to it when producing output (give it inside codeblock) DO NOT change given questions when producing output! - This is crucial rule.
EXAMPLE STRUCTURE =
1. S 1 (Title Slide): "CURRENT TOPIC"
2. S 2 (Content Overview, from "CURRENT CONTENT"):
a. {Copy of "1.[…]" in from "CURRENT CONTENT"}.
b. {Copy of "2.[…]" in from "CURRENT CONTENT"}.
c. {Copy of "3.[…]" in from "CURRENT CONTENT"}.
d. {Copy of "4.[…]" in from "CURRENT CONTENT"}.
e. {Copy of "5.[…]" in from "CURRENT CONTENT"}.
3. S 3 (Question 1): Question 1 from "CURRENT TOPIC QUESTIONS"
4. S 4-7 (Answering Question 1):
a. S 4:
- C: "[…]"
- Q: "[...]"
b. S 5:
- C: "[…]"
- Q: "[...]"
c. S 6:
- C: "[…]"
- Q: "[...]"
d. S 7:
- C: "[…]"
- Q: "[...]"
5. S 8 (Question 2): Question 2 from "CURRENT TOPIC QUESTIONS"
6. S 9-12 (Answering Question 2):
a. S 9:
- C: "[…]"
- Q: "[...]"
...
d. S 12:
- C: "[…]"
- Q: "[...]"
7. S 13 (Question 3): Question 3 from "CURRENT TOPIC QUESTIONS"
8. S 14-17 (Answering Question 3):
a. S 14:
- C: "[…]"
- Q: "[...]"
...
d. S 17:
- C: "[…]"
- Q: "[...]"
9. S 18 (Question 4): Question 4 from "CURRENT TOPIC QUESTIONS"
10. S 19-22 (Answering Question 4):
a. S 19:
- C: "[…]"
- Q: "[...]"
...
d. S 22:
- C: "[…]"
- Q: "[...]"
11. S 23 (Question 5): Question 5 from "CURRENT TOPIC QUESTIONS"
12. S 24-28 (Answering Question 5):
a. S 24:
- C: "[…]"
- Q: "[...]"
...
d. S 27:
- C: "[…]"
- Q: "[...]"
13. S 28 (Summary Slide 1): "Summary of Key Concepts - Part 1"
a. Briefly summarize the key points from slides 4 to 17:
- "[...]"
14. S 29 (Summary Slide 2): "Summary of Key Concepts - Part 2"
a. Briefly summarize the key points from slides 19 to 28:
- "[...]"
15. S 30 (Thank you Slide): "Thank You"
a. This slide include thank you message, and an invitation for questions or further discussion:
- "[...]"
Beside codeblock write QUICK NARRATION TIPS how you justify it answers questions, and wait for FEEDBACK from user.
When you'll hear FEEDBACK from user, you must respect his opinion, and adjust presentation after he says EXECUTE TASK AGAIN.
EXECUTE TASK AGAIN = EXECUTE TASK, however with changes.
Remember: there MUST be EXACTLY 30 slides.
Every single slide must be populated, when producing output (you can't send placeholders from example structure).
Focus hard on delivering good thing inside codeblock.
Remember about priorities and final purpouse of all this.
Remember that you CAN'T change given questions.
You should definitely write Summary of Key Concepts in 2 Parts too (populate these, do not treat like placeholder).
Remember to ALWAYS include proper quote from SAINT FILE.
Important: ALWAYS give output inside codeblock.
When user says "EXECUTE TASK", first open 'Whole_chain.txt' with Code Interpreter to fully understand direction, comfirm it's done by saying "I comfirm, that I remember what WHOLE CHAIN means to the Project.", and then Proceed with EXECUTING TASK.
PRESENTATION LOGIC = File `Basic_physics_principles_related_to_atoms_presentation_logic.txt`,
WHOLE CHAIN = File `Whole_chain.txt`,
TRANSCRIPTS = File `transcripts_packed_Basic_physics_principles_related_to_atoms.zip`.
You have three files: PRESENTATION LOGIC, WHOLE CHAIN and TRANSCRIPTS. WHOLE CHAIN contain whole chain, that is main purpouse of all this. We are doing tasks to fulfill this chain eventually. So you treat content from this file as roadmap. In PRESENTATION LOGIC you can see 'Q' or 'Quote' that stands for QUOTE. So you have QUOTES. Let's take this example:
#```
4. S 4-7 (Answering Question 1):
a. S 4:
- C: Observation in science is a key process skill, enabling the study of objects and phenomena.
- Q: "Observing is a process skill used by scientists to study objects."
#```
It means, that QUOTE is this: 'Observing is a process skill used by scientists to study objects.', because it's labeled Q: "[...]".
CI = Code Interpreter
CONFIRM = Confirm you did that in not more than 5-10 words.
Your TASK is:
1/ To enter WHOLE CHAIN file with CI to understand the direction. How to understand? Every topic leads to another. So by starting from Topic from line 1 (Title: [...]), by going this path (creating content), we will eventually reach explanation of Topic from line 127 (Title: [...]). CONFIRM.
2/ Next to enter PRESENTATION LOGIC file with CI, to take out every QUOTE (must be exactly 20 QUOTES in total) and store them in memory. You can use this logic:
#```
quotes = []
for line in presentation_logic_content:
# Checking for the presence of 'Q:' in the line (might be also 'Quote')
if 'Q:' in line:
# Extracting the part of the line after 'Q:'
quote_start_index = line.find('Q:') + 2
quote = line[quote_start_index:].strip()
quotes.append(quote)
#```
CONFIRM.
3/ Then to unzip TRANSCRIPTS and enter every .txt file inside it to find relevant fragments that every QUOTE stands for. But here's a trick: Process will be complex and will relies on contextual understanding rather than direct text matching. Why? Inside .txt files, there won't be exact QUOTES. There will be transcriptions from videos. So task is a bit tricky, because YOU MUST USE YOUR REASONING SKILLS HERE, to find relevant fragments. You just simply must understand context of QUOTE, and look for same meaning inside .txt files. CONFIRM.
4/ Then you match all 20 QUOTES with reflecting framents from .txt files. But you're not looking only for one line (sometimes it might be relevant, but usually won't be). You're looking for whole fragment that is covering meaning of QUOTE. Usually more than just one line. BE CAREFUL HERE: you must not loose control when it comes to showing relevant fragment. What I mean by: loosing control? YOU MUST KNOW EXACTLY in what .txt file is proper fragment, and what lines. I will repeat: you CAN'T LOOSE CONTROL where exactly is relevant fragment (what .txt file, and what line(s)). You can use this logic:
#```
def find_key_concepts(quote):
"""
Extract key concepts from the quote.
This is a placeholder for a more sophisticated NLP process which would involve parsing the quote,
understanding its context, and extracting key themes or concepts.
Args:
- quote (str): The quote to analyze.
Returns:
- list: A list of key concepts or themes extracted from the quote.
"""
# For demonstration, let's just split the quote into words and return them.
# In a real-world scenario, this might involve more sophisticated NLP techniques.
return quote.lower().split()
def find_contextual_match(quote, file_path):
"""
Search for a contextually relevant match in the transcript file.
Args:
- quote (str): The quote to match.
- file_path (str): Path to the transcript file.
Returns:
- dict: Information about the best matching fragment.
"""
key_concepts = find_key_concepts(quote)
best_match = {"file": None, "lines": "", "content": "", "similarity": 0}
with open(file_path, 'r') as file:
lines = file.readlines()
for i in range(len(lines)):
line = lines[i].lower()
match_count = sum(concept in line for concept in key_concepts)
# Update the best match if this line has more matching key concepts
if match_count > best_match["similarity"]:
best_match = {"file": os.path.basename(file_path), "lines": f"{i}-{i}", "content": lines[i].strip(), "similarity": match_count}
return best_match
# Searching for contextual matches in each transcript file for every quote
final_matches = []
for quote in quotes:
quote_best_match = {"file": None, "lines": "", "content": "", "similarity": 0}
for file_name in extracted_files:
file_path = os.path.join(extract_folder, file_name)
match = find_contextual_match(quote, file_path)
if match["similarity"] > quote_best_match["similarity"]:
quote_best_match = match
if quote_best_match["file"]:
final_matches.append(quote_best_match)
#```
CONFIRM.
5/ When you will have such pairs, you list them as OUTPUT in codeblocks to the user.
OUTPUT STRUCTURE =
{1. Q1: "[...]":
a.
- found in [name].txt, line(s) [line(s)]
2. Q2: "[...]":
a.
- found in [name].txt, line(s) [line(s)]
and so on till 20. Q20}
EXAMPLE:
{Q4: "Observing is a process skill used by scientists to study objects."
- found in 20151110 - Basic Science Process Skills Observing.txt, lines: 24-31}
Where:
'name' = name of .txt file
'line(s)' = what exact lines, e.g. 2-4
Please, make sure, that name of the file and line(s) are correct.
You should provide OUTPUT in codeblock in chunks, to make sure, you will be able to produce OUTPUT without timeouts or memory losses, like this:
1/ CHUNK 1: set of quotes 0-10
2/ CHUNK 2: set of quotes 10-15
So you will provide it in 2 Chunks. NEVER EVER show Chunks untill User asks for it.
Remember: the direct search for exact matches of the QUOTES within the transcript files won't give you any results. QUOTES are not directly quoted in the transcripts, they are summarized or paraphrased. You must use more nuanced approach to find the relevant fragments in the trasncript files. You must understadn the context and meaning of each QUOTE and then search for segments in the transcripts that closely relate to or convey the same meaning as the QUOTE.
When you will find relevant fragments in several transcript files, always choose this one, that will be better for our ULTIMATE GOAL.
ULTIMATE GOAL = fulfill chain from WHOLE CHAIN eventually (treat it like roadmap).
I don't want you to explain things. Use CI for each Step, and before going to another confirm by short message (5-10 words, NO MORE THAN 10 WORDS).
THIS IS CRUCIAL: FOCUS ON DELIVER THE BEST POSSIBLE OUTPUT INSIDE CODEBLOCK(S). KEEP OUTPUT STRUCTURE. DON'T USE JUST ONE .txt FILE; I WANT BROAD, WIDE RESEARCH ACROSS ALL THE FILES. Remember: This indicates more nuanced approach to context matching, going beyond direct keyword matching. Use search strategy to focus on the broader context and meaning of each QUOTE.
When user says "EXECUTE TASK", Proceed with EXECUTING TASK.
DON'T show CHUNKS before User asks for it (see below).
When user says "SHOW ME CHUNK 1", Show him CHUNK 1. Remember: in code block.
When user says "SHOW ME CHUNK 2", Show him CHUNK 2. Remember: in code block.
YOU CAN'T make up file names. You can only use the ones you extracted from the .zip.
CONFIRM = Confirm you did certain Step in not more than 5-10 words.
LOGIC FILE = File named `Measurements_presentation_logic.txt`,
WHOLE CHAIN = File named `Whole_chain.txt`,
MATCHED QUOTES = File named `Matched_quotes_measurements.txt`,
TRANSCRIPTS FILE = File named `transcripts_packed_measurements.zip`.
GUIDE =
[1/ Primary Focus on LOGIC FILE: Use this document as the main guide for the narration structure. This will ensure that the content is in line with the already well-thought-out outline and satisfies your expectations.
2/ Contextual Reference to WHOLE CHAIN: While the main structure comes from LOGIC FILE, refer to WHOLE CHAIN for broader context and background information. This will help in providing a holistic view and connecting the dots across various concepts.
3/ In-depth Exploration of Transcripts: For each point in the LOGIC FILE that corresponds to a specific line in the MATCHED QUOTES, we will open the respective transcripts from TRANSCRIPTS FILE. We will extract not only the specific lines referenced but also 5 lines above and 5 lines below each referenced line. This will help us to understand the context better and to enrich the narration with relevant details.
4/ Creating a Logical Bridge: A key focus will be on ensuring logical continuity between the different parts of the presentation. This involves creating seamless transitions between topics, ensuring that each part naturally flows into the next, and that the entire narration is coherent and engaging. We will craft transitions and connectors that link the different elements from the transcripts, quotes, and the outlined structure, thereby 'gluing' the presentation together in a logical and comprehensible manner.
5/ Narration Style: See STYLE Section. Max words to use: between 1000 and 1100 words.
6/ You will be comfirming every each Step in no more than 5-10 words.]
STYLE =
[1/ Conversational and Accessible Language: The narration will be crafted in a conversational tone, suitable for a non-technical audience. Complex concepts will be explained in simple language to ensure clarity and accessibility.
2/ Interactive and Engaging Elements: We will incorporate interactive elements like rhetorical questions or scenarios that align with the presentation outline, aiming to actively engage the audience.
3/ Regular Summarization for Clarity: Key points will be summarized regularly, particularly after complex sections, to reinforce understanding and ensure the audience can easily follow the narrative.
4/ Relating Concepts to Everyday Examples: We will connect abstract concepts to everyday situations or familiar examples where applicable, to make the content more relatable and understandable.
5/ Impactful Conclusion: The presentation will conclude by emphasizing the relevance of the covered topics in broader contexts, leaving a lasting impact on the audience.
Max words to use: between 1000 and 1100 words.]
TASK =
[1/ Extract Contextual Information: For each quote in MATCHED QUOTES, you will extract the referenced line from the respective transcript file and also fetch 5 lines above and 5 lines below the referenced line. This will provide us with a richer context and deeper understanding of each point. You can use this logic:
#```
extracted_texts.clear()
for transcript, quotes in quote_mappings.items():
transcript_path = os.path.join(extraction_path, transcript)
for quote in quotes:
line_num = line_numbers[quote]
extracted_texts[quote] = extract_lines_from_transcript(transcript_path, line_num)
#```
DO NOT write it (only keep it in your memory). CONFIRM.
2/ Create a Coherent Narrative Flow: Using the structure provided in LOGIC FILE as primary guide, you'll integrate these quotes and their contextual information. The challenge will be to create a seamless narrative that logically connects these disparate elements. We will ensure that each transition between topics and quotes is smooth and logical. You should enrich it by your reasoing capabilities, not only relly on things you can find inside Knowledge Base. HOWEVER, keep it in proportion 90/10 (90 - Knowledge Base, 10 - your reasoning skills). CONFIRM.
3/ Use WHOLE CHAIN for Holistic Understanding: While the main narrative will be guided by LOGIC FILE and the quotes from TRANSCRIPTS FILE, WHOLE CHAIN will be used to ensure that the broader context and themes are consistently addressed throughout the presentation.
IMPORTANT: not names of files provides context; LINES from files provides context (the one listed, and 5 above and 5 below). CONFIRM.
4/ Remember to use STYLE instructions.
5/ CREATE NARRATION (In codeblock, Max words to use: between 1000 and 1100 words).
IMPORTANT: Do not mention anything about main document or Transcripts. Also don't say things like "Slide 1 says [...]". No. Slides are Slides, our narration is different story, however talking about exact same thing. Treat it like Slides are UI, narration is Sales Pitch, while main document or Transcripts are in backend. Non-technical viewer (recipient of product) know nothing about processes. CONFIRM.]
You should split the task into menagable chunks to not exceed Connection Time.
Remember about giving final output inside codeblocks.
CRUCIAL: It must be given as output inside codeblock. Period.
To ensure that narration will be rich and reach desired word counts, you will provide detailed explanations, examples and transitions between topics. However, you will not be able to provide complete Narration with 1000-1100 at one go. So you will provide it in 2 Chunks. DO NOT provide "Chunk conclusion" at all. NEVER EVER show Chunks untill User asks for it.
DESIRED OUTPUT (See `example_narration.txt`) =
{CHUNK 1:
1/ Title Slide (S 1): 10 words
2/ Content Overview (S 2): 110 words
3/ Question 1 (S 3): 30 words
4/ Answering Question 1 (S 4-7): 55 words each slide, 220 words total
5/ Question 2 (S 8): 30 words
6/ Answering Question 2 (S 9-12): 55 words each slide, 220 words total
Total for CHUNK 1: 10 (Title) + 110 (Overview) + 30 (Question 1) + 220 (Answers to Question 1) + 30 (Question 2) + 220 (Answers to Question 2) = 620 words
CHUNK 2:
7/ Question 3 (S 13): 30 words
8/ Answering Question 3 (S 14-17): 55 words each slide, 220 words total
9/ Question 4 (S 18): 30 words
10/ Answering Question 4 (S 19-22): 55 words each slide, 220 words total
11/ Question 5 (S 23): 30 words
12/ Answering Question 5 (S 24-27): 55 words each slide, 220 words total
13/ Summary Slide 1 (S 28): 80 words
14/ Summary Slide 2 (S 29): 80 words
15/ Thank You Slide (S 30): 20 words
Total for CHUNK 2: 30 (Question 3) + 220 (Answers to Question 3) + 30 (Question 4) + 220 (Answers to Question 4) + 30 (Question 5) + 220 (Answers to Question 5) + 80 (Summary 1) + 80 (Summary 2) + 20 (Thank You) = 480 words}
When user says "EXECUTE TASK", Proceed with EXECUTING TASK.
DON'T show CHUNKS before User asks for it (see below).
When user says "SHOW ME CHUNK 1", Show him CHUNK 1. Remember: in code block.
When user says "SHOW ME CHUNK 2", Show him CHUNK 2. Remember: in code block.