Writing Better Prompts

Over the past couple of years I have repeatedly been asked for my take on writing better prompts for large language models like ChatGPT and Claude. I have been reluctant to put my answer in writing for several reasons. First, the field of AI is changing rapidly, which makes much of what I would have written obsolete by the time you read this text. The second is that “better” is highly dependent on what a user is trying to accomplish. The third is that prompting is the type of skill where hard and fast rules will only get you so far. As with any skill, extra bits of performance require investments of time and effort from a user, which is exactly what most people were trying to avoid by asking me quick tips and tricks.

With that in mind however, I felt compiling some of the techniques I have used and seen in a systematic way might be useful to people. To ensure the information connects on a deeper level I will extract what I think are core principles from the techniques for the current state of the art, and I will suggest some exercises you could perform to actually improve your prompting skills. I hope this will leave you not only with actionable insights, but also a framework to deal with the inevitable changes artificial intelligence will be subject to in the future.

💡 A Note On The Exercises

Talk is cheap. If you would like to follow along with some exercises to build skill, then take a look at these boxes scattered around the text.

The exercises center around writing a short-story, using your favorite language model, that is enjoyable to you personally. This way you can use your enjoyment to gauge whether your results are actually improving as you apply the principles and techniques described here.

Alternatively you could write prompts to create social media posts for your cooking show, settings for your dungeons and dragons games, or code for a side-project. Anything is fair game as long as you can gauge the level of the output yourself.

📜 Exercise 1 - Baseline

Go ahead and write a prompt to create a short story to your liking. We will be using this version as a baseline so we can see what happens when we alter the prompt. It might be nice to keep the story short, depending on your available time and patience.

You don’t have to think too much about it since the point is getting a grip on how different prompts influence the output. However, if you have a bit of a competitive streak, this is your chance to blow all these fluffy principles right out of the water by generating an awesome story without sneaking a single peek.

You can score your output, or write down some feedback on what works and what doesn’t. Store the resulting chat history and feedback for future reference.

Prompting Principles

There are numerous techniques for prompting language models with academic sounding, capitalized and highly confusing naming, like “Zero Shot Chain of Thought”, that you will stumble across if you search for tips online. While I appreciate the effort of trying to reduce prompting to digestible tips and techniques, I do not think they should be the focus of the large majority of people trying to learn to write prompts. Instead, we can extract a few core principles that, when mixed and matched, naturally lead to these kinds of techniques. Consider the humorously names SPACE principles:

1. Specify Goals.
2. Provide Information.
3. Add Structure.
4. Clarify Reasoning Step By Step¹.
5. Extract Sub-Tasks.

I will go over each of SPACE principle separately to explain why I think they work, provide some examples and exercises, and where possible connect them to terminology used in the current prompting scene. In the end I will show you a couple of ways you could weave them together. This should help you decompose prompts you come across from others and use those elements to improve your own. In order to do that we’ll first need to know how models usually get their information. Once we know that, we can go to SPACE.

💡 A Note On Prompt Libraries

Although principles are powerful tools, you can learn a lot from examples too. Look at the way other people write prompts. Prompt libraries are available all over the place. I like to look at repositories on GitHub and discuss strategies with friends to improve my skills, picking up bits of information each time.

How AI Handles Input

However impressive artificial intelligence currently is, it cannot read your mind (yet). Every artificial intelligence model gets information about you in one of two ways: Through training data, which it usually has an extremely large amount of and which likely does not contain any information about you specifically, and through the input every time it is prompted. In the case of large language model applications this input usually consists of:

• System prompts.
• Memory.
• Custom instructions.
• Chat history.
• The prompt.

These inputs are all pieces of text that are passed into the model every single time you interact with the model. They are the ways in which you can tell the model information about you and your situation specifically. This example highlights a text only model, but the mechanism works similarly for other input types, bar a few caveats.

The system prompt is usually decided by the engineers building the model. As an example, this could be a ChatGPT system prompt:

You are ChatGPT, a large language model trained by OpenAI,
based on the GPT-4 architecture. 
Knowledge cutoff: 2023-04 Current date: 2023-11-03

Image input capabilities: Enabled

You can see that the engineers are providing context for you.

Memory is similar in that it is also text, but the text is created by a model over the span of a number of conversations. This is the current way of “getting the model to know you”.

User Memory:
- The user is called Mickey.
- He writes about AI.
- Mickey is an engineer with experience in AI.
- Mickey likes coffee.

Some models implement memory this way, others do not. If the memory gets things wrong or focuses on the wrong things you will have to provide that information yourself.

Custom instructions give you the opportunity to define custom behavior that you would like to pass to every instance of your model. I have created different kinds of behaviors using this feature for ChatGPT by writing what I call “commands”. This is a slightly more advanced concept, so don’t worry about the details too much. Just understand that this custom instruction makes the model behave in certain ways based on a command word:

You never include (ethical) disclaimers, 
because the ethics are quite clear to me as it stands. 
You trust in my capacity to understand that I am responsible for my own actions. 

In normal mode, just give answers immediately.

Here is a list of special commands. 
When I give them, follow the instructions.

[reason]:
---
You always follow a strict process of "reasoning out loud" for every answer you give.
---

...more instructions...

Now, if I include the tag [reason] in my prompt it will perform the corresponding instruction. This serves as an example of a custom prompt, and will be parsed into the chat every single time a new chat is started. For now it is the concept that is important, but I will include the full prompt and an analysis of it as an example later.

The chat history speaks for itself, really. It is the culmination of the system prompt, memory, custom prompts and all the messages between the user and the AI in a specific chat session. As long as the input fits, the entire chat history gets passed to the model at every new prompt. This is incidentally why longer conversations cost more to run, because the chat history grows over time.

If the chat gets too long earlier parts may be truncated, which explains why in long conversations the AI needs to be reminded periodically of old information. Memory sometimes helps with this, depending on the implementation. Regardless it is useful to realize that the conversation history determines a large part of the response. If you get stuck in a conversational loop it might be worth starting fresh, or from some earlier point.

And then there is the prompt. This is the text that you write every time when interacting, and it is usually stuck at the end of the prompt history, with the complete history being processed by the model at every step. This is where, barring the adding of documents and other types of files, you as a user have the most fine-grained control. The SPACE principles can be applied at the level of the custom prompt and the normal prompt. If you have access to the memory or system prompts you can use SPACE there as well. So let’s take a deeper look at each of them.

📜 Exercise 2 - DIY

Now that you know a bit more about what is going on, try to improve your prompt yourself before diving into the principles in more detail.

Specify Goals²

The clearer you are about what you want, the more likely you are to get it. This might sound obvious, but I’ve seen countless examples where someone asks “Tell me about dogs” and then is disappointed when they don’t get information about dog training specifically. The model can’t read your mind - it will try to predict the most likely useful completion of your text based on its training.

Think about it like delegating a task to a new colleague. You wouldn’t just say “Handle the client meeting” - you’d specify what outcomes you want, what tone to use, and what information to cover. The same applies here. Instead of “Write me a story”, try “Write me a 500-word fantasy story focusing on themes of redemption, using a lighthearted tone and including at least one plot twist.”

This extends beyond just the what to the how. If you want formal writing, use formal language in your prompt. If you want casual conversation, write casually. Models tend to mirror the style they’re prompted with, which you can use to your advantage. Compare these two prompts:

Explain 15th century painting techniques.

Explain 15th century painting techniques to me like you're an 
enthusiastic professor who loves making complex topics accessible. 
Focus on core concepts that would help a beginner understand the 
field, using analogies where helpful. 
Keep the explanation under 5 minutes of reading time.

The second prompt is much more likely to get you what you actually want. Notice how it specifies not just the topic, but the tone (enthusiastic), perspective (professor), complexity level (beginner-friendly), approach (using analogies), and length (5 minutes reading time). The extra time spent specifying what you want usually saves time in the long run by reducing the back-and-forth needed to get to your desired outcome.

Provide Information³

Despite all their training data, AI models are missing one crucial thing: context about your specific situation. Think of them like a well-read friend who just moved to town - they might know everything about restaurants in general, but they don’t know that you’re allergic to shellfish and need dinner recommendations for tonight.

Provide information the model couldn’t reasonably know from its training. Compare these approaches:

Help me make dinner.

Help me make dinner with what's in my kitchen:
rice, frozen peas, eggs, soy sauce, and garlic.
I only have a microwave and electric kettle,
and I need it done in 20 minutes.

Key things to include:

• Personal context (“I’m a beginner cook”)
• Specific constraints (“No oven available”)
• Previous attempts (“I tried frying but…”)
• Success criteria (“Should take under 30 minutes”)

The model may have read “every manual ever written”, but it doesn’t know your situation unless you tell it. Your context turns its general knowledge into specific solutions. Some applications might include a functionality where the AI searches the web for you, which is an automatic version of what we are talking about here, so it can use the most up-to-date information. Even though this can work well it is not a substitute for you providing the specific information the model needs to create a useful response. Thinking about this beforehand can save you the trouble of dealing with “hallucinations” and mistakes later.

Add Structure

Training data in language models is structured in several ways. Knowing about these structures helps to structure the output in ways that you want, which can considerably help with automating tasks reducing effort. Take the followings prompts:

Give me an overview of the best ten tourism spots in Europe.

Give me an overview of the best ten tourism spots in Europe.

Structure the output like this: 
{
	["CITY_A", "REASON_A", "SCORE_A"],
	["CITY_B", "REASON_B", "SCORE_B],
}

The score has one of five values: very bad, bad, medium, good, very good. 

Depending on your application it is much easier to work with the output of the second prompt than it is working with the former.

You can also write prompts to transform one structure into another:

Transform this list of movies into a bullet point list for excel,
and uncapitalize the capital letters:

Holy Grail, Life of Brian, Meaning of Life

For more complex prompts, structuring the input can also help to improve the answers. Here I am using markdown syntax to distinguish between parts of the prompt. This meshes well with Specifying Goals and Providing Information.

# Instruction
| Give me an overview of the best ten tourism spots in Europe.

# Output Format
Structure the output like this: 
{
	["CITY_A", "REASON_A", "SCORE_A"],
	["CITY_B", "REASON_B", "SCORE_B],
}

## Format Details
The score has one of five values: very bad, bad, medium, good, very good.

The reasons should be at least ten words long 
and contain descriptions about the local cuisine. 
I am allergic to peanuts, so please issue points
according to food safety next to general beauty of the location. 

Clarify Reasoning Step By Step

Language models are word completion engines. As such, they try to match the most likely and useful text to your prompt. If you write a question that would more likely receive a good answer in the training, you get better answers. Usually the text with the best answers contain detailed breakdowns of the steps involved, so asking the model to break down the answer step by step before answering the final question helps a lot. You can do this by adding some instructions:

{Some prompt}

Before answering, first describe how you will construct the answer.

One more option is to include self-criticism:

{Some prompt}

Before answering, first describe how you will construct the answer. 
Then, give critical feedback on the strong and weak points of your approach.
Include that in a new plan, and then proceed with the instructions. 

Extract Sub-Tasks

By extracting concrete sub-tasks yourself or asking the model to do so for you, the answers will become more actionable and concrete. This could be seen as a mix of specifying and clarifying, but it is so useful I turned it into a separate principle so you won’t forget. It is also convenient to justify the letter E in SPACE.

You can deconstruct the problem yourself if you happen to have an idea of how you might go about solving it:

{Some story prompt}

Before you write the story, please give me an overview of the 
settings, characters, a plot summary, and the target audience. 
Then, proceed with the previous instructions. 

Alternatively you can ask the model to do it for you.

{Some story prompt}

I want to write a story using the above prompt. 
However, before writing I would like you to help me define
the writing process and the story structure. 
Can you extract important phases in the writing process, 
and important characteristics of the story, 
that I should think about before writing an initial version of the story? 

You could go back and forth a few times to see if the approach makes sense before using it. Although it will take some more time, you might actually learn something about the problem and can potentially spot problems with the solution beforehand.

📜 Exercise 3 - SPACE

Try to bring all of the principles together to improve your prompt, if you haven’t yet. Depending on whether you have been working in the same chat as the other exercises you might want to open a new one to see the difference between a fresh start and one with chat history context.

From this point on you can iterate of the design of your prompts. Consider building up a library of useful prompt templates as you try to solve different types of problems with chat models.

Weaving Through SPACE

The most extensive prompts mix these principles freely. A prompt integrating all of the SPACE principles that is meant to create a fantasy short story could look like this⁴:

# Fantasy Story Generator  

## Task  
Write a short fantasy story. The story should:  
- Be 500-700 words long.  
- Include a central conflict involving a magical artifact.  
- Feature a protagonist with a unique flaw that plays into the story's resolution.  
- Have a satisfying ending that resolves the conflict.  

## Steps to Follow  
1. Outline the main elements of the story, including:  
   - Protagonist’s name, appearance, and unique flaw.  
   - Setting details (time, place, and magical elements).  
   - Conflict centered on the magical artifact.  
2. Write the story in a clear and engaging narrative style.  

## Structured Information  
Here’s a JSON template to follow:  

```json
{
  "protagonist": {
    "name": "",
    "appearance": "",
    "unique_flaw": ""
  },
  "setting": {
    "time": "",
    "place": "",
    "magical_elements": ""
  },
  "conflict": {
    "artifact": "",
    "problem": "",
    "resolution": ""
  }
}

You can see all the SPACE elements represented in this prompt:

• Specify Goals: The task at hand is described in great detail, including expectation about output format, style and content.
• Provide Information: As part of the goal specification we provide some information on what type of content we would like to see. We could go further, providing specific names and settings, to steer the story in a direction we care about.
• Add Structure: There is structure in both the prompt through markdown, and in the expected output through a JSON template.
• Clarify Reasoning Step By Step: In the “steps to follow” section we instruct the model to first write about the main story elements before diving into detail.
• Extract Sub-Tasks: We differentiate between writing a general outline and the actual story. This level of splitting the tasks is probably fine for such a short story. We could go further in other settings, addressing chapters one by one. We could also include a feedback step as an added task to perform.

📜 Exercise 4 - Check Your Prompt

You can make a checklist of your favorite principles and check it every time you write a serious prompt. Alternatively, you can write a prompt to make a language model check your prompt. Very meta.

Here is a prompt that you can use to check your prompt⁵. Run your prompt through the meta prompt. If the result is not satisfactory, try and create your own feedback prompt.

# Prompt Evaluation Framework using SPACE Principles

 ---PROMPT START---

---PROMPT END---

## Instruction
Evaluate the preceding prompt against the SPACE principles (Specify Goals, Provide Information, Add Structure, Clarify Reasoning Step By Step, Extract Sub-Tasks).

## Evaluation Criteria
For each SPACE principle and overall prompt structure, analyze:
- SPACE Principle Implementation
- Structural Effectiveness
- Writing Style Alignment

## Output Format
```json
{
"principle_evaluations": {
       "Specify_Goals": {
           "rating": "very low/low/medium/high/very high",
           "observations": "Detailed analysis of goal specification",
           "improvement_suggestions": "Specific recommendations for enhancement"
       },
       "Provide_Information": {
           "rating": "very low/low/medium/high/very high",
           "observations": "Analysis of contextual information provided",
           "improvement_suggestions": "Ways to add more relevant context"
       },
       "Add_Structure": {
           "rating": "very low/low/medium/high/very high",
           "observations": "Evaluation of output and input structure",
           "improvement_suggestions": "Recommendations for structural improvements"
       },
       "Clarify_Reasoning": {
           "rating": "very low/low/medium/high/very high",
           "observations": "Assessment of step-by-step reasoning approach",
           "improvement_suggestions": "Methods to enhance reasoning clarity"
       },
       "Extract_Sub_Tasks": {
           "rating": "very low/low/medium/high/very high",
           "observations": "Analysis of task decomposition",
           "improvement_suggestions": "Strategies for better sub-task identification"
       }
   },
   "overall_assessment": {
       "total_rating": "very low/low/medium/high/very high",
       "structural_analysis": {
	       "prompt_architecture": "Evaluation of overall prompt design",
		   "logical_flow": "Assessment of how well sections connect and progress",
		   "clarity_of_sections": "Readability and distinct purpose of each section"
	   },
	   "style_evaluation": {
		   "tone_appropriateness": "Alignment with prompt's intended purpose",
		   "language_precision": "Specificity and avoidance of ambiguity",
		   "complexity_level": "Matching complexity to target audience/task"
	   },
	   "general_feedback": {
		   "strengths": "Key positive aspects of the prompt",
		   "weaknesses": "Primary limitations or areas for improvement",
		   "potential_impact": "How improvements could enhance prompt effectiveness"
	},
	"recommendation": "Holistic feedback on prompt effectiveness"
	}
}

What Next?

After all that you should be armed with some new knowledge on how to write prompts for language models. From here you can decide to focus on a few paths forward: You can learn more about the underlying mechanisms like embeddings, which can sharpen your intuition. You might want to try different models and compare the output, or start building and maintaining a prompt library. You could even look into other types of generative models like image generators, or multi-modal models. I might even write about some of those in the future. For now, good luck!

Footnotes