Generating Prompt Data for the LLM Prediction Game

Welcome back! In the previous lesson, you learned about the LLM Prediction Game — how it works, how players interact with it, and how their guesses are scored. Now, we are ready to start building the data that powers the game.

In this lesson, you will learn how to generate the prompt data that the game uses to ask questions. This data is essential because it provides the daily questions and the structure that the game relies on. By the end of this lesson, you will know how to create a set of prompts, each with a question, some settings, and a few random elements to keep the game interesting.

Before we dive in, let’s quickly remind ourselves of a few Python basics that will be useful in this lesson:

• Lists: A way to store multiple items in a single variable.
• Dictionaries: A way to store data in key-value pairs, allowing you to quickly look up values by their keys. For example, {"llm": "gpt-5.4-nano", "user_question": "What is the capital of Spain?"}.
• Random Selection: The random module helps us pick random items from a list.
• Saving Files: We use the open() function and the json module to write data to a file.

If you need a refresher on any of these, feel free to look at Python documentation. Otherwise, let’s move forward!

Each prompt entry in our game is a small package of information. Let’s break down what each entry contains:

• llm: The name of the language model we are using (for example, "gpt-5.4-nano").
• system_prompt: Instructions for the model (for example, "You are a helpful assistant. Your answers must only contain 10 words in plain text, do not use markdown.").
• user_question: The question that will be shown to the player.
• breakpoints: A list of numbers that will be used later in the game logic.

Let’s look at a simple example of what one entry might look like in Python:

entry = {
    "llm": "gpt-5.4-nano",
    "system_prompt": "You are a helpful assistant. Your answers must only contain 10 words in plain text, do not use markdown.",
    "user_question": "What is the capital of Spain?",
    "breakpoints": [2, 3, 4]
}

This dictionary holds all the information for one prompt. In the next steps, we’ll see how to generate many of these entries automatically.

To make the game interesting, we want a variety of questions and some randomness in the breakpoints. Let’s build this step by step.

First, we need a list of topics or nouns that our questions will be about. Here’s a small example:

nouns = [
    "the capital of Spain",
    "the tallest mountain",
    "the boiling point of water"
]

We can use these nouns to create questions by combining them with a template. For example:

user_questions = [f"What is {noun}?" for noun in nouns]
print(user_questions)

Output:

['What is the capital of Spain?', 'What is the tallest mountain?', 'What is the boiling point of water?']

This gives us a list of questions ready to use.

We want each prompt to have a set of breakpoints. Let’s create a list of possible breakpoint options and pick one at random for each entry.

import random

random.seed(0) # Set the seed to 0 for reproducibility

breakpoint_options = [
    [2, 3, 4],
    [1, 2, 3],
    [3, 4, 5]
]

random_breakpoints = random.choice(breakpoint_options)
print(random_breakpoints)

Output (example):

[1, 2, 3]

As we set the seed to 0, each time you run this you will get the same selection. If you want to get a different set of breakpoints, be sure to not set the seed of the random library.

Now, let’s put it all together for one entry:

entry = {
    "llm": "gpt-5.4-nano",
    "system_prompt": "You are a helpful assistant. Your answers must only contain 10 words in plain text, do not use markdown.",
    "user_question": user_questions[0],
    "breakpoints": random.choice(breakpoint_options)
}
print(entry)

Output (example):

{
    "llm": "gpt-5.4-nano",
    "system_prompt": "You are a helpful assistant. Your answers must only contain 10 words in plain text, do not use markdown.",
    "user_question": "What is the capital of Spain?",
    "breakpoints": [3, 4, 5]
}

Once we have many entries, we want to save them so the game can use them later. We use the json module for this.

Let’s say we want to create 3 entries and save them:

import json

entries = []
for i in range(3):
    entry = {
        "llm": "gpt-5.4-nano",
        "system_prompt": "You are a helpful assistant. Your answers must only contain 10 words in plain text, do not use markdown.",
        "user_question": user_questions[i],
        "breakpoints": random.choice(breakpoint_options)
    }
    entries.append(entry)

with open("data.json", "w") as f:
    json.dump(entries, f, indent=2)

This code creates a list of entries and writes them to a file called data.json. The indent=2 part makes the file easy to read.

Note: On CodeSignal, the json module and file writing are ready to use, so you don’t need to install anything extra. If you run this on your own computer, make sure you have permission to write files in your working directory.

In this lesson, you learned how to:

• Build the structure for a prompt entry.
• Generate a list of user questions from a set of topics.
• Randomly select breakpoints for each entry.
• Assemble and save all the prompt data to a JSON file.

This prompt data is the foundation for the LLM Prediction Game. In the next set of exercises, you’ll get hands-on practice generating and saving prompt data yourself. This will prepare you for the next steps in building the game. Good luck!