Joel StevickStart here · 15 episodes · 3 h 14 min
Every episode, in order
Two free video series for software engineers with no generative AI background. Start at episode 1 and go down the page: each episode builds on the one before it, ends with something working, and has its code as a tag in the course repository.
Series 1 · 8 episodes · 1 h 40 min
From engineer to AI engineer
From the software you already write to an AI pipeline that answers from your own documents and cites its sources.
-
Episode 1 · 13:36
What actually changed, and what didn't
A model is a function you call over HTTP: text in, text out, no state between calls, a different answer each time, priced by the token. HTTP, databases, tests and deployment are unchanged, and they are most of the job.
At the end: your first call to a model, from the terminal.
-
Episode 2 · 10:48
Calling a model from code
The Messages API is an HTTP API like any other. Tokens, the context window, the system prompt, and what each call costs.
At the end: a command-line assistant in TypeScript, and a question it cannot answer, because the answer is in documents it has never seen.
-
Episode 3 · 11:26
Prompts are code
Structured output you can parse as JSON, tool use where the model calls your functions, and the agent loop that runs them.
At the end: the model calling a function in your own code.
-
Episode 4 · 9:42
Why it can't read your documents
A model knows its training data, and your documents were never in it. Pasting them into the prompt works: one file, then all twelve, both answered right. But every question pays to read them all again, and with thirty times the documents they no longer fit in the window. Retrieval is the fix.
At the end: the whole folder pasted into one prompt, the right answer, and what that costs on every question.
-
Episode 5 · 15:07
Embeddings and cosine similarity
An embedding model turns a text into a vector, and cosine similarity compares two of them by meaning. Inside the extractor: how the tokenizer splits text into tokens, why Firefly 220R is one token away from Firefly 220, and how a vector per token is pooled into one. The math is shown on real vectors: the angle, the projection, the dot product, and a 3D view of the corpus. The vectors go in a SQLite table, searched with a loop, with no commercial vector database, so you see what one does for you.
At the end: a search by meaning over 414 paragraphs, on your own machine, with no API key, and the two places it fails: two products one letter apart, and headings lost in the split.
-
Episode 6 · 11:14
Ingestion is ETL
Extract the text of Markdown and PDF files, page by page. Split it into chunks at headings, then by size with an overlap. Load every chunk into SQLite with its vector and where it came from (the file, the heading or the page), with a hash per file so a second run re-indexes only what changed.
At the end: 287 chunks from 13 files in three and a half seconds, a second run that embeds nothing, and a search that finds the bench fee on page one of the PDF.
-
Episode 7 · 13:07
Your first pipeline
The whole pipeline: retrieve the passages, build the prompt, answer with citations, and say "I don't know" when the passages don't support an answer, behind a web endpoint.
At the end: the pipeline answering with its sources, and ten questions with known answers that score it.
-
Episode 8 · 14:41
Making it good, with numbers
Four changes, each scored on the same ten questions: hybrid keyword and vector search, reranking, widening the pool, and a citation check written in code. One of them makes it worse.
At the end: a measured improvement, and the one question that still fails.
Series 2 · 7 episodes · 1 h 34 min
Prove it works
An eval harness: tests for the pipeline from series 1. A set of questions with known answers, a score for every run, and a gate in CI that blocks a change that makes the answers worse.
-
Episode 1 · 13:28
The golden set
Why ten questions are not enough. A golden set built from real questions: what each case holds, the facts an answer must contain, the passages it must cite, what it must not say, and the cases where the right answer is "I don't know".
At the end: a golden set of thirty cases in JSONL.
-
Episode 2 · 12:15
Models as a parameter
Dependency injection and scripted models, so the test suite never calls a model and the eval passes in the real ones.
At the end: the test suite green in CI with no API key.
-
Episode 3 · 12:50
The tracer
A tracer that records every step of a run: the query, the retrieved chunks, the prompt, the answer and the cost, and how to read a trace.
At the end: a trace for every case.
-
Episode 4 · 16:46
Scoring
Retrieval first, then deterministic answer checks, then an LLM judge, and an eval of the judge itself. The fallback is scored too.
At the end: a scored run.
-
Episode 5 · 12:54
Caps, the ledger and comparing runs
A budget for every run, every run recorded in a ledger, and two runs compared so a regression is caught before it ships.
At the end: a change proven or reverted by its numbers.
-
Episode 6 · 12:26
Diagnosing a failure
A retrieval miss, an answer miss, a citation miss and a wrong fallback, how each is told apart, and what fixes each.
At the end: one of each found and fixed.
-
Episode 7 · 13:33
The harness as a gate
It runs on every change in CI, production questions are sampled into the golden set, and the monthly run catches drift and model deprecations.
At the end: the harness blocking a bad change.
Shorts · about a minute each
Why this path, in a minute
Two short videos on why I made the series and what the path is.
-
Short · 0:48
AI took my job
AI tools let cheaper developers replace me. I delivered DoorDash while I figured out what to do next, and what I found under the hype was real engineering: new problems, and good ones. Nobody showed me the path from software developer to AI engineer, so I'm showing you.
-
Short · 1:09
How to become an AI engineer, in 3 steps
Step one: understand what AI engineering is. It's not using AI to write your code; it's building software with a model inside it and engineering it so you can trust what it does. Step two: learn the fundamentals, a RAG pipeline and an eval harness. Step three: build your own from the starter repos.