The Builder’s Road

Every chat assistant you have used is, underneath, a program sending text to a model and printing what comes back. The surprising thing is how little code that takes. The hard parts — choosing what to send, checking what returns, keeping it safe and affordable — are craft, not magic. This track is where you stop being only a user and start being a builder. You do not need to be a programmer yet. You need patience, a computer, and a willingness to read error messages slowly.

Who this track is for

The Builder track is for three kinds of reader. The first has finished the Practitioner track and keeps thinking “I wish I could make it do this automatically.” The second is a developer who writes software for a living but has never trained a model or called a language-model API. The third is an analyst — finance, operations, research, public service — who lives in spreadsheets and wants to go further than a spreadsheet allows.

The first pages assume no coding at all. By the end you will have written real machine learning code and a small application built on a large language model. You will not need university mathematics here; that waits for the Advanced track.

This guide’s framing We teach classic machine learning before language-model APIs on purpose. Splitting data, measuring error and spotting overfitting are the habits that keep LLM applications honest too; skipping them is how people ship demos that fall over in real use.

What you will build

The track has eleven more pages. Here is the road, in order — tap a title to open it:

1. Python essentials for AIJust enough Python — variables, lists, dictionaries, loops, functions and reading files — to follow every later page.
2. Working with dataNumPy for arrays of numbers, pandas for tables, and the unglamorous art of cleaning messy, real-world data.
3. The machine learning workflowSplit your data, train, evaluate on a held-out test set, and iterate — the loop behind every model.
4. Classic modelsLinear and logistic regression, decision trees, nearest neighbours and clustering, using scikit-learn.
5. Measuring modelsAccuracy, precision, recall and why a 99% accurate model can still be useless.
6. Calling LLM APIsMessages, tokens, streaming responses and how to estimate and control cost.
7. Embeddings and semantic searchTurning meaning into lists of numbers so a program can find “similar” text.
8. Retrieval-augmented generationGrounding a model’s answers in your own documents, with citations you can check.
9. Tool use and agentsLetting a model call functions you write — safely, with limits and logs.
10. Shipping an AI appA simple interface, deployment, monitoring and guardrails.
11. Builder capstoneDesign, build and ship your own small assistant from start to finish.

Each page builds on the ones before it, so work through them in order the first time.

Setting up your workshop

You need four things. None costs money.

Here is the whole set-up in a terminal. Lines beginning with # are comments.

# make a project folder and a virtual environment inside it
mkdir ai-builder
cd ai-builder
python3 -m venv .venv
# on Windows:  py -m venv .venv

# switch it on (macOS / Linux)
source .venv/bin/activate
# on Windows PowerShell instead:  .venv\Scripts\Activate.ps1
# (if PowerShell refuses to run scripts, see the venv documentation linked below)

# install the libraries this track uses
pip install numpy pandas scikit-learn jupyter

# store an API key for this terminal session (never in a file you share).
# Typed commands are also saved in your shell's history file, so for regular
# use keep keys in a .env file that is listed in .gitignore.
export MY_LLM_API_KEY="paste-key-here"
# Windows PowerShell:  $env:MY_LLM_API_KEY = "paste-key-here"

Handling API keys safely

Later pages call language models through a paid service. The service gives you an API key: a long secret that proves who you are and charges your account. Anyone who has it can spend your money. Keys pasted into code end up on GitHub, where automated scanners find them within minutes. So follow three rules from day one:

• Keep keys in environment variables (or a .env file that is listed in .gitignore), never typed into your code.
• Never paste a key into a chat — not into an AI assistant, not into a forum post, not into a screenshot asking for help.
• Set a spending limit on your account and revoke any key you suspect has leaked. Revoking is instant; regret is not.

Your Python code then reads the key from the environment:

import os

api_key = os.environ.get("MY_LLM_API_KEY")
if api_key is None:
    raise SystemExit("Set MY_LLM_API_KEY first - never write the key in this file.")
print("Key loaded, ending in", api_key[-4:])   # show only the last 4 characters

Your first AI-flavoured program

Before touching any API, let us build a tiny language model ourselves. It is a bigram model — an n-gram model with n = 2: it learns which word tends to follow which, then guesses the next word by rolling weighted dice. This is, in miniature, the same job a large language model does: predict the next token. The difference is that an LLM looks at thousands of previous tokens with billions of parameters; ours looks at one word with a table of counts.

import random
from collections import Counter, defaultdict

text = """the cat sat on the mat . the dog sat on the rug .
the cat saw the dog . the dog chased the cat ."""

words = text.split()
followers = defaultdict(Counter)
for current, nxt in zip(words, words[1:]):
    followers[current][nxt] += 1

print(followers["the"].most_common(3))

def guess_next(word):
    counts = followers[word]
    return random.choices(list(counts), weights=counts.values())[0]

word, sentence = "the", ["the"]
while word != "." and len(sentence) < 12:
    word = guess_next(word)
    sentence.append(word)
print(" ".join(sentence))

Line by line:

• Imports. random rolls the dice; Counter counts things; defaultdict is a dictionary that creates an empty entry the first time you mention a new key.
• text is our whole training data — two lines. The full stops are separated by spaces so they count as “words”, which gives the model a way to end a sentence.
• words = text.split() breaks the text at spaces and line breaks into a list: ["the", "cat", "sat", …]. This is the crudest possible tokeniser.
• The for loop walks through every neighbouring pair. zip(words, words[1:]) lines the list up against itself shifted by one, giving (“the”, “cat”), (“cat”, “sat”) and so on. For each pair we add one to the count of next after current. That loop is the entire “training”.
• The first print shows what the model learned about “the”: [('cat', 3), ('dog', 3), ('mat', 1)].
• guess_next looks up the counts for a word and picks a follower at random, weighted by the counts — so “cat” is three times as likely as “mat”. This is sampling, the same idea as temperature in a chat model.
• The while loop starts at “the” and keeps guessing until it produces a full stop or reaches 12 words. Run it a few times: you will get “the cat sat on the rug .” and also nonsense like “the cat saw the cat sat on the dog .”

That nonsense is the lesson. With one word of memory, the model is locally fluent and globally confused. Give it a longer memory, far more text and learned representations instead of raw counts, and you are on the road that led to GPT. Try swapping text for a few paragraphs of your own writing, or a public-domain book, and watch the output become more stylish and no more sensible.

How to practise

People who learn to build with AI tend to share a few habits.

• Make tiny things that work, often. A script that sorts your downloads folder, a word counter for your essays, a model that predicts house prices from a public dataset. Finished and small beats ambitious and abandoned.
• Read the error, bottom line first. Python’s traceback ends with the error type and message (KeyError: 'cat'); the lines above show where it happened. Most beginner errors are spelling, indentation or a missing import.
• Use an AI coding assistant — as a tutor, not a ghostwriter. Ask it to explain an error, suggest a test, or review your code. If it writes code for you, make sure you can explain every line before you run it; if you cannot, ask it to explain, then rewrite the code yourself. Assistants confidently invent library functions that do not exist, so run and test everything. And never paste secrets or confidential data into the chat.
• Keep a log. A plain notes file of what you tried, what broke and what fixed it becomes your personal manual.
• Use version control early. Learning Git basics lets you experiment boldly, because you can always go back.

Free resources to lean on

These pair well with this track; all are free to use.

• The official Python tutorial — terse but authoritative.
• Al Sweigart, Automate the Boring Stuff with Python — free online, built around practical everyday scripts.
• Kaggle Learn — short, hands-on micro-courses in Python, pandas and machine learning, run in the browser.
• CS50’s Introduction to Artificial Intelligence with Python (Harvard) — free lectures and projects once you are comfortable with Python.
• The scikit-learn user guide — the reference for classic models, full of clear examples.

For a longer list sorted by level, see Courses, Books and Resources.

Key terms on this page

Sources & further reading

• Python Software Foundation, venv — Creation of virtual environments (Python documentation).
• Claude Shannon, “A Mathematical Theory of Communication”, Bell System Technical Journal (1948) — the first n-gram text generation experiments.
• Daniel Jurafsky & James H. Martin, Speech and Language Processing, 3rd edition draft — chapter on n-gram language models (free online).
• GitHub Docs, About secret scanning — why committed keys are found quickly.
• Al Sweigart, Automate the Boring Stuff with Python, 3rd edition (No Starch Press, 2025; free to read online).