YVCode

After six episodes on how to build a model, the honest finale asks the question you should ask first: should you even build one? For most people, most of the time, the answer is no, and that's not defeat, it's good engineering. This capstone lays out the ladder of options, from prompting an existing model, to retrieval, to fine-tuning, all the way up to full pretraining, and the gates that tell you which rung you actually need. We recap the whole pipeline (vessel, ore, fire, post-training, evals) through the lens of one decision: build versus buy. A clear-eyed way to spend your effort where it actually pays.

Hosted by AI-generated voices (made with NotebookLM).

You've built the model. Now the hardest question: is it actually any good? Measuring a language model turns out to be far trickier than it looks, and the benchmark numbers everyone quotes can quietly mislead you. This episode is the assayer's problem, testing the purity of what came out of the furnace. We walk through the ways measurement breaks: contaminated test sets, benchmarks that reward the wrong thing, scores that don't survive contact with real use, and the trap of trusting a single headline number. If you only take one habit from the whole series, make it this one: distrust a good score until you know exactly where it came from.

Hosted by AI-generated voices (made with NotebookLM).

Everyone knows the story: Captain Kirk's communicator inspired the first cell phone. It's a wonderful story, and it's not true. The man who actually invented the handheld phone says so himself. This opening episode of Star Trek: Make It Real sets up the whole series and the honesty framework it runs on, sorting every Trek "prediction" into one of three boxes: predicted, inspired, or coincidence. Where a resemblance is not enough, where you need a real engineer on the record, and where the show's most famous legends fall apart under a single checked source. We're not here to flatter Star Trek or debunk it, but to find the real line between the dream and the built thing. So we boldly go where no man has gone.

Hosted by AI-generated voices (made with NotebookLM).

You've fired the furnace and a model comes out, but a freshly trained model isn't an assistant. It's a raw next-word predictor that will happily continue your question with three more questions. This episode is about post-training: the steps that turn that raw furnace into something helpful and steerable. We walk through supervised fine-tuning (teaching by example) and preference tuning (teaching the model what "better" looks like), and how the same underlying predictor gets shaped into an assistant that follows instructions, and increasingly, one that reasons. Plain language, real trade-offs, engineer to engineer.

Hosted by AI-generated voices (made with NotebookLM).

Filtered vector search runs underneath almost every AI product you've used. A common way to speed it up is to partition your data and search only the relevant pieces. But when does that actually work, and when does it quietly fail? This episode's answer is a single measurable number: cluster concentration, or c-one, the fraction of a query's true neighbors that live in its own partition. Measure it before you build, and it predicts whether a partitioned index can work at all.

The finding arrived the hard way. A "56x faster" result turned out to be a measurement artifact, shrinking to 6.9x, then 2.1x, then nothing at all on the next dataset, each honest correction moving the number the same direction. What survived wasn't a speedup but a diagnostic, plus an uncomfortable truth: the standard synthetic benchmark sits at the geometric extreme real data never reaches, and upgrading to a better embedding model can silently break a partitioned index. A story where the method wins, not the algorithm.

Hosted by AI-generated voices (made with NotebookLM).

You've got the blueprint and you've got the ore. Now you light the fire, and this is the part that costs real money. This episode is about training compute: the one equation that actually governs what a training run costs, and how to reason about it before you spend anything. We look at where compute quietly leaks away, why the theoretical number and the bill you actually pay are two different things, and what it takes to run the enormous, expensive, unglamorous process of teaching a model. Plain language, real trade-offs, and the arithmetic that decides whether your ambition is fundable.

Hosted by AI-generated voices (made with NotebookLM).

Here's a secret that surprises people: the biggest lever on how good your model turns out isn't the architecture or even the size. It's the data. This episode is about the ore you load into the furnace, and why most of what you dig up is garbage. We look at how the great open training datasets are actually built and filtered, why ruthless quality control beats raw quantity, and how the same pile of text can produce a brilliant model or a mediocre one depending entirely on what you keep and what you throw away. If you only understand one part of the model-building pipeline, the working engineers will tell you: make it this one.

Hosted by AI-generated voices (made with NotebookLM).

Open up GPT, Llama, Claude, Mistral, and under the hood they're startlingly alike. Why? This episode is the blueprint of the vessel: the handful of architecture decisions the whole field has quietly settled on, and why they won. We walk through the design choices that shape everything downstream, and then the piece almost nobody talks about but that secretly governs what your model costs to run: the KV cache. If Episode 1 opened the rooms of the black box, this one is the architect's drawing, the decisions you make before you ever light the fire, explained engineer-to-engineer with the real trade-offs on the table.

Hosted by AI-generated voices (made with NotebookLM).

People call a language model a "black box," but it's not one solid box it's a building with rooms, and each one does a specific, understandable job. This first episode of How To Build A Model opens the door and walks you through them. How raw text becomes tokens, why a word is stored as a vector and not a symbol, what the "residual stream" running down the middle of the model actually carries, and how attention and the feedforward layers read from and write to it. It's the whole architecture of next-token prediction, explained the way one engineer would explain it to another, no notation required. By the end, the box isn't black anymore.

Hosted by AI-generated voices (made with NotebookLM).

A raw next-word predictor isn't an assistant. It'll happily complete your question with three more questions. This finale of The LLM Story tells how that gap was closed, how a giant prediction machine was steered into something helpful, honest, and safe to talk to. We cover the RLHF turn (teaching a model to want what you want through human feedback), Constitutional AI, the ChatGPT moment that put it in everyone's hands, and then the leap beyond: chain-of-thought reasoning, retrieval, cheaper capacity, and models that learn to pause and think before answering. And we close the whole arc, from Shannon's guessing game to today's reasoning agents, on the thesis that ties all five episodes together: it was never a new bet, only a deeper machine for the same one, predicting what comes next.

Hosted by AI-generated voices (made with NotebookLM).