Generating Prompt Data

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 review a few JavaScript basics that will be useful in this lesson:

• Arrays: A way to store multiple items in a single variable, using square brackets [].
• Random Selection: The Math.random() function helps us pick random items from an array.
• Saving Files: In Node.js, we use the fs module and JSON.stringify() to write data to a file.

If you need a refresher on any of these, feel free to look at the JavaScript 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").
• systemPrompt: 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.").
• userQuestion: The question that will be shown to the player.
• breakpoints: An array 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 JavaScript:

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

This object 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:

const 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:

const userQuestions = nouns.map(noun => `What is ${noun}?`);
console.log(userQuestions);

Output:

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

This gives us an array of questions ready to use.

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

const breakpointOptions = [
  [2, 3, 4],
  [1, 2, 3],
  [3, 4, 5]
];

function choice(arr) {
  return arr[Math.floor(Math.random() * arr.length)];
}

const randomBreakpoints = choice(breakpointOptions);
console.log(randomBreakpoints);

Output (example):

[1, 2, 3]

Note: In JavaScript, there is no built-in way to set a random seed for reproducibility as in some other languages. Each time you run this code, you may get a different selection.

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

const entry = {
  llm: "gpt-5.4-nano",
  systemPrompt: "You are a helpful assistant. Your answers must only contain 10 words in plain text, do not use markdown.",
  userQuestion: userQuestions[0],
  breakpoints: choice(breakpointOptions)
};
console.log(entry);

Output (example):

{
  llm: 'gpt-5.4-nano',
  systemPrompt: 'You are a helpful assistant. Your answers must only contain 10 words in plain text, do not use markdown.',
  userQuestion: '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. In Node.js, we use the fs module and JSON.stringify() for this.

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

const fs = require('fs');

const entries = [];
for (let i = 0; i < 3; i++) {
  const entry = {
    llm: "gpt-5.4-nano",
    systemPrompt: "You are a helpful assistant. Your answers must only contain 10 words in plain text, do not use markdown.",
    userQuestion: userQuestions[i],
    breakpoints: choice(breakpointOptions)
  };
  entries.push(entry);
}

fs.writeFileSync("data.json", JSON.stringify(entries, null, 2), "utf-8");

This code creates an array of entries and writes them to a file called data.json. The null, 2 part in JSON.stringify makes the file easy to read.

Note: This code works in a Node.js environment, not in the browser. 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!