Selecting the Daily Prompt for the LLM Prediction Game

Welcome back! In the previous lesson, you learned how to generate and store prompt data for the LLM Prediction Game. Now, let’s see how to use that data to make the game dynamic and engaging for players.

A key part of the game is that each day, players see a new prompt. This keeps the game fresh and gives everyone the same challenge for that day. In this lesson, you’ll learn how to select the correct prompt for today using the data you’ve already created.

By the end of this lesson, you’ll understand how the game picks a prompt based on the current date, loads it from your JSON file, and handles any issues that might come up. You will use the datetime, json and pathlib libraries to achieve this. This is an important step in making your game feel like a real daily challenge!

Before we dive into selecting the daily prompt, let’s get familiar with the main files and folders in your project. Here’s a quick overview of what each file does:

.
|-prediction_game
|  |-static
|  |  |-prompts
|  |  |  |-prompt_generator.py   # Script to generate and save daily prompts into data.json
|  |  |  |-data.json             # JSON file containing the list of daily prompts for the game
|  |  |-style.css                # CSS file for styling the game's web interface
|  |  |-script.js                # JavaScript file for client-side interactivity and UI logic
|  |-main.py                     # FastAPI entry point for running the web application
|  |-app
|  |  |-db.py                    # Database engine, session maker, and dependency injection for SQLAlchemy
|  |  |-models.py                # SQLAlchemy ORM models (e.g., HighScore table)
|  |  |-game.py                  # Core game logic, including prompt selection and game state management
|  |  |-leaderboard.py           # Logic for storing and retrieving leaderboard scores
|  |  |-llm.py                   # Functions for interacting with the language model (LLM) API
|  |  |-scorer.py                # Logic for scoring player responses using semantic similarity
|  |  |-routes.py                # FastAPI API routes and request/response schemas
|  |-templates
|  |  |-index.html               # Main HTML template for rendering the game's web page

This structure helps keep your code organized and makes it easy to find where different parts of the game are implemented. In this lesson we will work on the game.py file.

To make sure everyone gets the same prompt on a given day, we need a way to pick a prompt based on the date. One simple and effective method is to use the "day of the year." This means:

• January 1 is day 1
• February 1 is day 32
• December 31 is day 365

Let’s see how you can get the day of the year in Python.

import datetime

today = datetime.date.today()
day_of_year = today.timetuple().tm_yday
print(day_of_year)

If today is March 1, this code will print 60 (or 61 in a leap year). This number will help us pick which prompt to use from our list.

Why use the day of the year?

• It’s simple: just a number from 1 to 365.
• It repeats every year, so you can reuse prompts.
• It makes sure everyone playing on the same day gets the same prompt.

Now, let’s load the prompt data you created earlier. The prompts are stored in a JSON file, usually at static/prompts/data.json. We need to read this file and make sure it has the right number of prompts.

Here’s how you can load the prompts:

import json
from pathlib import Path

PROMPTS_PATH = Path("static/prompts/data.json")

def load_all_prompts():
    if not PROMPTS_PATH.exists():
        raise FileNotFoundError(f"Prompt file not found at {PROMPTS_PATH}")
    with open(PROMPTS_PATH, "r", encoding="utf-8") as f:
        return json.load(f)

Explanation:

• We use Path from the pathlib module to handle the file path.
• We check if the file exists. If not, we raise an error.
• We open the file and load its contents using json.load().

Once loaded, let’s also make sure the file has the correct number of prompts. For a daily game, you usually want 365 prompts (one for each day of the year):

TOTAL_PROMPTS = 365

all_prompts = load_all_prompts()
if len(all_prompts) != TOTAL_PROMPTS:
    raise ValueError(f"Expected {TOTAL_PROMPTS} prompts, but found {len(all_prompts)}")

This check helps catch mistakes early, such as missing or extra prompts.

Now that you have all the prompts loaded and validated, let’s select the prompt for today.

First, remember that Python lists are zero-indexed. That means the first item is at index 0, the second at index 1, and so on. However, our day of the year starts at 1. So, we need to subtract 1 to get the correct index.

Let’s put it all together step by step.

import datetime

def _get_day_of_year(date: datetime.date = None) -> int:
    date = date or datetime.date.today()
    day_of_year = date.timetuple().tm_yday
    return min(day_of_year, 365)  # Clamp to 365 in case of leap year

• If no date is given, we use today’s date.
• We use tm_yday to get the day of the year.
• We use min(day_of_year, 365) to make sure we don’t go past 365, even in a leap year.

The leading underscore in _get_day_of_year is a Python naming convention that indicates the function is intended for internal use within the module. It signals to other developers that this function is a "private" helper and not part of the module's public API. This helps keep the code organized and makes it clear which functions are meant to be used only inside the module, rather than being called from other parts of the application.

def get_daily_prompt(date: datetime.date = None) -> dict:
    all_prompts = load_all_prompts()
    if len(all_prompts) != TOTAL_PROMPTS:
        raise ValueError(f"Expected {TOTAL_PROMPTS} prompts, but found {len(all_prompts)}")

    day_index = _get_day_of_year(date) - 1  # 0-indexed
    return all_prompts[day_index]

• We load and validate the prompts.
• We calculate the correct index for today’s prompt.
• We return the prompt for today.

Example Output:

Suppose today is January 2 (day 2 of the year). The function will return the second prompt in your list.

prompt = get_daily_prompt()
print(prompt)

Output (example):

{
    "breakpoints": [1, 2, 4],
    "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 liver's function?"
}

In this lesson, you learned how to select the correct daily prompt for your LLM Prediction Game:

• You used the day of the year to pick which prompt to show.
• You loaded and validated your prompt data from a JSON file.
• You handled possible errors, such as missing files or the wrong number of prompts.
• You made sure to use the right index so the game always shows the correct prompt for today.

Next, you’ll get to practice these steps yourself. You’ll write code to select prompts, handle errors, and see how your game can deliver a new challenge every day. Good luck, and have fun!