Project: Predicting the Future - Points, Performance & Breakouts (Basketball)

Introduction

Basketball prediction starts with simple models. If we know recent production and expected minutes, we can estimate what might happen next game.

In this project, you will build a lightweight prediction model and flag breakout-watch games.

What we're building

By the end of this project, you will:

  • Store player data in dictionaries
  • Detect trends in recent scoring
  • Predict next-game points from recent rates
  • Classify breakout potential with clear rules

Why this matters

Most advanced models start with a simple baseline. If you can build and explain a baseline model, you are thinking like an analyst.

Part 1: Quick Start

Set up your project in Cursor

For this project, you will create your files from scratch (no starter pack download).

Before you start: quick vocabulary

  • A folder is a container that holds files.
  • A file is one item inside a folder.
  • A file extension is the ending in the file name:
    • .py means Python code.
    • .csv means table-style data.
  1. Pick an easy location for your project folder:
    • Mac: Desktop in Finder
    • Windows: Desktop in File Explorer
    • Chromebook: My files in the Files app
  2. Create a folder called basketball-performance-predictor.
  3. In Cursor, go to File > Open Folder and open basketball-performance-predictor.
  4. In Cursor's left file explorer:
    • click New Folder and create data
    • click New File and create performance_predictor.py
    • open data, click New File, and create recent_games.csv
  5. If you do not see file extensions on your computer, that is okay. Type the full names exactly, including .py and .csv.

Writing the code

Type this into performance_predictor.py:

recent_points = [18, 22, 25, 21, 27]
recent_minutes = [30, 32, 35, 31, 34]
projected_minutes = 33

points_per_minute = sum(recent_points) / sum(recent_minutes)
predicted_points = points_per_minute * projected_minutes

print(f"Predicted points next game: {predicted_points:.1f}")

You just built a simple model: prediction = scoring rate x projected minutes

Running the code

Save the file (Cmd + S on Mac, Ctrl + S on Windows/Chromebook).

Run the file with Cursor's built-in Run Python File play button in the top-right.

If the play button is missing, install/enable the Python extension in Cursor and reopen performance_predictor.py.

Expected output:

Predicted points next game: 23.7

If your output matches, your project setup is working.

Part 2: Project Milestones

Milestone 1: Store player data in a dictionary

Dictionaries let you give each value a name ("season_average", "recent_points") instead of remembering index positions.

Add this below your existing code:

player = {
    "name": "Jalen Carter",
    "team": "Greenville Comets",
    "season_average": 20.8,
    "recent_points": [18, 22, 25, 21, 27],
    "recent_minutes": [30, 32, 35, 31, 34]
}

print(player["name"])
print(player["recent_points"])

Expected output:

Jalen Carter
[18, 22, 25, 21, 27]

Milestone 2: Build reusable prediction functions

Now wrap your logic into reusable functions. This makes your code easier to test and reuse for other players.

Add this below Milestone 1:

def average(values):
    return sum(values) / len(values)

def predict_points(recent_points, recent_minutes, projected_minutes):
    points_per_minute = sum(recent_points) / sum(recent_minutes)
    return points_per_minute * projected_minutes

projected_minutes = 33
prediction = predict_points(
    player["recent_points"],
    player["recent_minutes"],
    projected_minutes
)

print(f"{player['name']} predicted points: {prediction:.1f}")

Expected output:

Jalen Carter predicted points: 23.7

Milestone 3: Detect trend direction

Prediction is not just one number. Analysts also ask: "Is this player trending up or down?"

Add this below your current code:

recent = player["recent_points"]
first_half_avg = average(recent[:2])
second_half_avg = average(recent[-2:])

if second_half_avg > first_half_avg:
    trend = "up"
elif second_half_avg < first_half_avg:
    trend = "down"
else:
    trend = "flat"

print(f"Trend: {trend}")

Expected output:

Trend: up

Milestone 4: Add breakout watch logic

Now turn prediction + season average into a category label.

Add this below your current code:

def breakout_label(predicted_points, season_average, breakout_margin):
    if predicted_points >= season_average + breakout_margin:
        return "Breakout watch"
    if predicted_points >= season_average:
        return "On pace"
    return "Below season pace"

tag = breakout_label(prediction, player["season_average"], 3.0)
print(f"Tag: {tag}")

Expected output:

Tag: Breakout watch

Milestone 5: Load recent game logs from CSV

Now you will keep game data in a CSV so you can update predictions without editing Python logic.

  1. Open data/recent_games.csv.
  2. Paste the data below.
  3. Save the file.
  4. Make sure the file name is exactly recent_games.csv (not recent_games.csv.txt).

Paste this into data/recent_games.csv:

date,points,minutes
2026-02-01,18,30
2026-02-03,22,32
2026-02-06,25,35
2026-02-08,21,31
2026-02-10,27,34

Now load that CSV in Python and re-run the prediction using file data. Add this below your existing code:

import csv

recent_points = []
recent_minutes = []

with open("data/recent_games.csv", "r") as file:
    reader = csv.DictReader(file)
    for row in reader:
        recent_points.append(float(row["points"]))
        recent_minutes.append(float(row["minutes"]))

player["recent_points"] = recent_points
player["recent_minutes"] = recent_minutes
prediction = predict_points(recent_points, recent_minutes, projected_minutes)

first_half_avg = average(recent_points[:2])
second_half_avg = average(recent_points[-2:])
if second_half_avg > first_half_avg:
    trend = "up"
elif second_half_avg < first_half_avg:
    trend = "down"
else:
    trend = "flat"

print(f"CSV-based prediction: {prediction:.1f}")

Click Run Python File again and verify your CSV-based prediction prints.

Expected output (your exact decimal may vary slightly):

CSV-based prediction: 23.7

Milestone 6: Build a final prediction card

Now combine prediction, trend, and tag in one clean report block.

Add this below Milestone 5:

tag = breakout_label(prediction, player["season_average"], 3.0)

print("=" * 46)
print(f"PREDICTION CARD: {player['name']}")
print("=" * 46)
print(f"Projected minutes: {projected_minutes}")
print(f"Predicted points: {prediction:.1f}")
print(f"Season average: {player['season_average']:.1f}")
print(f"Trend: {trend}")
print(f"Tag: {tag}")
print("=" * 46)

Expected result:

  • A final prediction card with projected minutes, prediction, season average, trend, and breakout tag.

If you made it this far, you built a complete basketball prediction workflow from scratch.

Common Fixes

  • FileNotFoundError: confirm the path is exactly data/recent_games.csv.
  • ValueError: check the CSV points and minutes columns are numeric.
  • No play button: install/enable Python extension in Cursor and reopen performance_predictor.py.

Bonus Exercises: Push It Further with Your Agent

Use this short prompt structure for better AI help:

  1. Goal: what you want to build
  2. Context: file name + what code already exists
  3. Constraints: keep beginner-friendly, minimal changes
  4. Output format: ask for exact code + where to paste + expected output

Bonus 1: Predict Multiple Players

Try this prompt:

You are my Python tutor and coding assistant.

Goal:
Predict points for 3 players and print one prediction card per player.

Context:
I am editing performance_predictor.py.
I already have predict_points(...), breakout_label(...), and a final prediction card format.

Constraints:
- Keep my current single-player flow working.
- Add only what is needed for multi-player support.
- Use beginner-friendly Python.

Output format:
1) Plan (3 bullets)
2) CSV format I should use
3) Exact code changes
4) Where to paste each code block
5) Example output for 2 players

Bonus 2: Add a Prediction Range

Try this prompt:

You are my Python tutor and coding assistant.

Goal:
Show low / medium / high prediction ranges instead of only one predicted value.

Context:
Current code calculates one prediction from recent points and minutes.

Constraints:
- Keep formulas simple (no advanced libraries).
- Explain the math in one short paragraph.
- Keep my current print card and add range lines.

Output format:
1) Range formula and reason
2) Code changes only
3) Expected output block
4) One way to tune the range width

Bonus 3: Compare Prediction vs Actual

Try this prompt:

You are my Python tutor and coding assistant.

Goal:
Compare predicted points to actual points and calculate prediction error.

Context:
I already compute prediction in performance_predictor.py.
I want to add this after the final prediction card.

Constraints:
- Keep this beginner-level.
- Show both signed error and absolute error.
- Do not remove existing outputs.

Output format:
1) Code block to add
2) Where to paste it
3) Expected output with sample numbers
4) One sentence explaining how to interpret error