Topic
Llama
8 episodes
-
Overview: Supervised Fine Tuning
We finally slow down and make supervised fine-tuning click, because we keep leaning on S F T like everyone already has the whole shape of it. We build it from the apprentice-and-worked-examples picture into the actual training loop, the examples, and the trade-offs.
-
Overview: Transformer Architecture
We finally sit down and define transformer architecture from the ground up, because we keep throwing the term around like it’s obvious and it really isn’t. We use the attention-as-a-room-of-index-cards picture to make the mechanism click, then connect it to why Transformers became the backbone of modern language models.
-
Viability of local models for coding
Birgitta Böckeler tests local LLM viability for coding after a year away from the space. She maps a complex web of factors—RAM, model size, quantization, tool calling, context windows, reasoning modes—that determine whether small models actually work for agentic coding on consumer hardware (M3 Max / M5 Pro). Her core finding: locals are runneable and faster than a year ago, but tool calling is still shaky, reasoning can backfire, and quality is hit-or-miss. She's not claiming local models are ready to replace cloud APIs; she's charting what actually works and what doesn't on real machines.
-
Overview: Tokenization
We slow down and explain tokenization from the ground up: how raw text becomes numbered pieces a model can process, why those pieces are usually subwords, and why the tokenizer quietly affects cost, context, language handling, and product behavior.
-
Skip a Layer or Loop It? Learning Program of Layers in LLMs
Justy and Cody dig into PoLar, a paper arguing that a pretrained LLM does not need to run its layers in one fixed order for every input. They talk through the main idea of treating layers like reusable functions that can be skipped or repeated, how the authors used Monte Carlo Tree Search to discover better layer programs, and why a lightweight predictor makes the idea more practical. The conversation centers on what problem this solves, why dynamic depth methods have been too narrow, and whether this feels like a research curiosity or an actual path to deployment.
-
Recursive Multi Agent Systems
RecursiveMAS is a new multi-agent framework from researchers at UIUC, Stanford, NVIDIA, and MIT that replaces text-based agent handoffs with latent-space recursion — cutting token usage by up to 75%, speeding up inference 2.4x, and improving accuracy by 8.3% across nine benchmarks. Justy and Cody dig into why passing hidden states instead of words is such a big deal, what the RecursiveLink module actually does, and whether any of this is shippable today.
-
6 Things I Learned Building LLMs From Scratch That No Tutorial Teaches You | Towards Data Science
Justy and Cody dig into what actually changes when you stop calling an LLM API and start building pieces yourself: why fine-tuning tricks like RsLoRA matter, why RoPE won, where weight tying still makes sense, why Pre-LN became the default, and how KV cache buys speed by spending memory.
-
Embarrassingly Simple Self Distillation Improves Code Generation
Apple researchers developed Simple Self-Distillation (SSD), a technique that improves code generation models by fine-tuning them on their own raw outputs—no verification needed. The method improved Qwen3-30B-Instruct from 42.4% to 55.3% pass@1 on LiveCodeBench by reshaping token distributions to balance precision and exploration in code generation.