Breaking Free from the 'All-in-One Prompt': Techniques to Dramatically Improve AI Accuracy by Separating Instructions from Cheat Sheets

Hello, this is Akari.

In my previous article, 'From Prompts to Agents: A Complete Map of the 4 Stages to Mastering AI,' we took a bird's-eye view of the entire landscape of AI utilization.

To be honest, the theme I most want to convey in this short series is how to handle Stage 2: 'Context (the background knowledge you provide to the AI).'.

People often think that 'mastering AI' is all about crafting the perfect prompt, but I want to start by breaking down that fixed idea.

So, in this installment, let's dive deep into the boundary between the first stage, 'Prompting,' and the second stage, 'Context.'

Have you ever felt exhausted after typing a massive, long-winded paragraph into the chat box when asking an AI for something?
Actually, that might be because the boundary between your prompt and your context has become blurred.

The True Nature of the 'Exhaustion' Caused by Fukatsu-style Prompts

The 'Fukatsu-style prompt' is a very famous prompt template. I have long been a fan of this type of prompt myself, and I consider it a kind of finished form.

This method, which clearly defines sections like '#Instructions,' '#Constraints,' '#Input,' and '#Output,' is a brilliant invention for eliciting high-precision responses from AI.

However, to be honest, don't you ever feel that 'it's a pain to construct that every single time...'?

Actually, there is a clear reason for that 'hassle' or 'exhaustion.'
It is becauseyou are trying to control everything about the AI with just a single prompt (text box).is.

Ideally, you are trying to cram not only the 'instructions' for the AI but also the 'background knowledge' you possess and the detailed 'rules' for the output into a single box (the prompt).
That is why the design becomes heavy and why it feels like a chore to input it every time.

Separating 'Instructions' from 'Background Knowledge'

To break free from this 'all-in-one' state, you need to clearly divide the roles.
That isthe separation of Stage 1 (Prompt) and Stage 2 (Context).is.

Let's organize their respective roles.

• Prompt (Instructions): 'Direct action instructions (Do)' for the AI

  • Example: 'Summarize this text,' 'Find the bug in this code,' 'Write a story with these settings'

• Context (Contextual Information): 'Background knowledge, context, and rules (What/Why)' for the AI

  • Example: 'Company product specifications,' 'Previous meeting minutes,' 'Detailed character profile settings'

Things get complicated because you mix these together. It is important to think about the 'action you want the AI to perform right now (instructions)' and the 'cheat sheet (background knowledge) the AI needs to perform that action' as completely separate things.

Techniques for Offloading to Context (External Information)

You might be thinking, 'Even if you say to separate them, don't I still have to write it all in the chat box?'

Certainly, if it is a context you only use once, it might be fine to write it directly into the chat box.
However, when we try to continuously create something using AI, there is always pre-existing knowledge that is used repeatedly present.

For example, when writing a novel.
World settings, character profiles, the overall plot, and the detailed plot for the current chapter are contexts that you use repeatedly in every prompt, right?
The same applies to writing note articles (blogs). Your writing style and preferences as an author, connections to past articles, and the roadmap for future articles are all contexts that are needed every time you write an article.
Also, additional training models like 'LoRA,' which are often used in image generation AI, can be considered a type of powerful context for fixing a specific art style or character.

An approach where you summarize such 'repeatedly used explanations (background knowledge and rules)' as an external file rather than in the chat box becomes extremely important.
Technologies like 'RAG (Retrieval-Augmented Generation)' that we hear about often lately are, in essence, mechanisms for 'having the AI read a cheat sheet summarized externally.'

You can create long character settings or past article data as separate 'configuration files (text, PDF, etc.)' and, when chatting with the AI, simply attach that file and give instructions in the prompt like this:

'Please read the attached setting materials and write a scene where these two characters are having a conversation at a cafe.'

What do you think?
Compared to when you were stuffing everything into the chat box (prompt), it has become much smarter, hasn't it?
This is the greatest merit of the technique of 'offloading to context.'

Let's converse with lightweight prompts

Prompt engineering is certainly important.
However, once you are freed from the spell that 'you must control everything with just the prompt,' interacting with AI becomes surprisingly easy.

Heavy 'background knowledge' and 'rules' should be prepared in advance as context (cheat sheets) and handed to the AI.
And the prompts we type should be dedicated to more lightweight, simple, and direct 'instructions.'

Just by being able to do this, the speed and accuracy of AI utilization will improve dramatically.

However, a question should arise here.
'How should I write the cheat sheet (context) to give to the AI so that it is best understood?'

Actually, there are clear tips for a 'cheat sheet that is easy for AI to read.'
Next time, I will thoroughly dissect how to write those cheat sheets—the secrets of 'structuring (Markdown and YAML),' which is the common language for talking to AI. Stay tuned!