Code With Wilson

I'm using AI to learn AI, and I'm publishing the journey as I go. Each episode is a NotebookLM-generated audio overview of a study brief I wrote — Chip Huyen chapters, LeetCode problem walkthroughs, AI Engineering interview topics. Built for myself, useful for anyone studying AI engineering for Google Cloud, Anthropic, OpenAI, or similar roles. Made transparently with NotebookLM (audio) and Claude (briefs). — Wilson Wu

45 episodes

1mo ago latest

4x a week cadence

English language

▶ Play latestRSS feed Website Technology Education How To

https://feed.codewithwilson.com/feed.xml

Episodes 45

The Launch Tax: How CUDA Graphs Keep Your GPU From Sitting Idle
1mo ago · 18:21
Running one token through a language model isn't one big GPU operation. It's hundreds to thousands of tiny ones, and each of those has to be launched by the CPU first. During decode, those little operations finish so fast the GPU starves waiting for the CPU to queue the next one. CUDA Graphs fix this by recording the whole repeating sequence once and replaying it with a single launch, so the GPU stays fed. Same math, same result, far less idle time.
The Model Is a Commodity: What an AI Engineer Actually Builds
1mo ago · 18:44
The single idea the entire craft rests on is this: the model is a commodity, and the system around it is the job. A raw frontier model is a brilliant intern with amnesia, no hands, and no way to check its own work. The AI engineer gives it hands through tools, a memory across runs, a way to verify itself through evals, and a loop that keeps working until the task is done. That wrapper — not the model weights — is the thing you get paid to build. Learn to build it and you're employable.
Attention Is Just Four Operations: How Every LLM Decides What to Read
1mo ago · 18:48
Scaled dot-product attention is not a mysterious black box. It's four elementary operations — matrix multiplication, transpose, scaling by a constant, and softmax — plus three learned projections that produce queries, keys, and values. You can write it in about a hundred lines of plain C with no autograd and no libraries. Once you see it as loops instead of magic, you reason about cost, memory, and failure modes from first principles rather than treating the model as a sealed device.
Serving Is a Separate Problem: How vLLM Runs LLMs Fast and Cheap
1mo ago · 18:34
An LLM engine like vLLM exists because serving a model well is its own systems problem, distinct from training it. Text generation is autoregressive and memory-bound, and the key-value cache is the real capacity limit on how many users fit on a GPU. vLLM answers three questions: which requests run next, how a batch executes, and where each request's cache lives. Its headline move is treating GPU memory like virtual memory, which slashes waste and unlocks bigger batches.
Learn to Drive Before You Study the Engine: The fast.ai Bet on Top-Down Deep Learning
1mo ago · 18:39
Most technical courses go bottom-up: math, then theory, then maybe you build something months later, by which point your motivation is gone. fast.ai flips it. You train a real, state-of-the-art model in lesson one, and only then peel back the layers to see how it learned. The engine that makes this possible for beginners is transfer learning, and that same "inherit capability instead of building it from scratch" move is the single most important pattern in modern AI engineering.
One Camera, One 3D World: How a Feed-Forward Model Rebuilds a Room at 20 Frames a Second
1mo ago · 19:23
A system called LingBot-Map turns a single moving camera into a live 3D map, a point cloud plus the camera's path through space, at roughly 20 frames per second and staying coherent across sequences of 10,000-plus frames. The magic is two ideas working together. First, it's feed-forward: one fast pass per frame instead of a slow optimization loop. Second, it borrows paged KV-cache attention from LLM serving so its memory doesn't explode over long streams. Seeing a language-model trick reappear in 3D vision is the whole point.
What a Production Agent Framework Actually Gives You: The Anatomy of Agno
1mo ago · 18:23
A raw model call is stateless and blind — it can't remember you, can't look anything up, and can't act. An agent is that model wrapped in the parts that fix each gap: tools, instructions, memory, knowledge, storage, and reasoning. A serious agent framework hands you those parts pre-assembled, plus a runtime to deploy them. The single most useful idea is that a framework is really a checklist of what every production agent needs — so reading one teaches you the whole shape of the problem.
When Two AI Models Shake Hands: The Whisk-to-Veo Pipeline
1mo ago · 18:55
Turning one photo into an on-model video clip is not one model doing something clever. It is two models chained together: Whisk makes a consistent still image, and Veo animates it into about eight seconds of motion. The entire skill is managing the handoff between them: matching the aspect ratio, carrying the seed and prompt across the boundary, and conditioning one model on the other's output. The moat is the pipeline, not the button.
Three Axes and Two Heresies: How Open Models Are Catching the Frontier
1mo ago · 21:19
The naive scaling law says more tokens equals more intelligence. The smarter move is to scale on three axes at once: token efficiency, context length, and agent swarms. And here's the reframe that ties it together, high-quality training data is finite, so squeezing more learning out of each token doesn't just save compute, it raises the ceiling of how smart a model can get. When data is the bottleneck, efficiency literally is capability.
Agent Swarms: Why One Smart Model Averages Away the Answer
1mo ago · 19:50
A single language model, asked to judge a hard decision, quietly averages every perspective it could hold into one cautious "on one hand, on the other hand" answer. An agent swarm refuses that. You spin up several experts, each pinned to a conflicting bias, have them analyze the same decision independently, then reconcile them without smoothing the clash. The disagreement is not noise to be cleaned up. It is the signal that shows you exactly where your decision is genuinely risky.
How Computers Read Code: Compilers, Machine Code, and the Call Stack
1mo ago · 15:29
There are always two versions of your program: the one you wrote and the one the machine runs. A processor understands only a tiny menu of operations — read bytes, write bytes, do math, jump around the instruction list, jump only if a flag is set. A compiler's entire job is to translate your variables, loops, and functions down into that menu. Once you see that translation, a huge amount of "why is my code slow, why won't this binary run, why is Python like that" stops being mysterious and becomes mechanical.
Architecture in the Middle: ISA vs Microarchitecture, and Why It Matters When You Build With AI
1mo ago · 18:53
Computer architecture is not the wiring. It's a layer of abstraction sitting in the middle of a stack that runs from Python at the top down to silicon at the bottom. Its whole job is to look both up at what software needs and down at what silicon allows, and strike a compromise. The single most useful distinction inside it is the instruction set architecture, the contract with software, versus the microarchitecture, the actual hardware that honors that contract. That interface-versus-implementation line is everywhere in systems.
The 671-Billion-Parameter Model That Fits on One Gaming GPU
1mo ago · 16:23
The single most important idea: giant Mixture-of-Experts models activate only a tiny fraction of their weights per token, so most of the model is idle dead weight at any instant. KTransformers exploits this by putting the small, hot, always-used pieces on a fast consumer GPU and banishing the enormous, rarely-touched pile of experts into cheap system RAM, where a modern CPU's matrix engine computes just the few that fire. The result: a 671-billion-parameter model on one 24-gigabyte card, at usable speed.
What Actually Gets Senior Engineers Hired: Reasoning Under Constraints
1mo ago · 21:45
Memorizing architecture diagrams is table stakes. What actually marks someone as senior is the ability to walk into an ambiguous problem, name the constraints out loud, make a defensible call, and say plainly what they chose, what they rejected, and what could break. Across seven areas, from HTTP fundamentals to working with AI, the same signal recurs: sound decisions made with incomplete information, and honesty about the failure modes. That narration is the whole game.
LeetCode #169 — Majority Element: How to Actually Think About It
3mo ago · 21:00
Day 2, Problem 1 of LeetCode's Top Interview 150. This is one of those rare problems where the *natural* solution is fine, the *clever* solution is good, and the *optimal* solution is famously elegant — to the point of being named after its inventor. The optimal solution is called the **Boyer-Moore Voting Algorithm**, and it's the kind of thing that takes 3 lines of code but earns "interview gold" status because most candidates can't explain *why* it works. This episode is going to spend serious time on the *reasoning*, because the algorithm itself is short — but the proof of correctness is wh
LeetCode #26 — Remove Duplicates from Sorted Array: How to Actually Think About It
3mo ago · 17:28
Day 1, Problem 3 of LeetCode's Top Interview 150. The headline lesson of this episode: **problem qualifiers like "sorted" aren't decoration. They're optimization unlocks.** This problem reuses the slow/fast two-pointer scaffold from #27 Remove Element with one tiny change in the filter rule — but the *real* lesson is *why* that change works, and that lesson generalizes to dozens of other problems. By the end of this episode you should be able to answer: (1) what does the word "sorted" actually give you? (2) why don't you need a hashset for this problem, even though it's a deduplication problem
LeetCode #27 — Remove Element: How to Actually Think About It
3mo ago · 17:50
Day 1, Problem 2 of LeetCode's Top Interview 150. This is the cleanest possible introduction to a pattern called **slow/fast two-pointer** — also known as the "read pointer, write pointer" idiom. It looks deceptively easy. The trap isn't in the algorithm; it's in *understanding what "remove" actually means* when the problem says "in-place." By the end of this episode you should be able to answer: (1) what does "remove" mean when you can't actually delete? (2) what's the difference between this problem's two pointers and the two pointers we used in Merge Sorted Array? (3) why is the time comple
LeetCode #88 — Merge Sorted Array: How to Actually Think About It
3mo ago · 15:49
This is the first problem in LeetCode's official "Top Interview 150" list — Day 1, Problem 1. If you can think clearly about this one, you have the foundation for roughly 30 other problems in the same family. This episode assumes you already know the 6-phase framework (understand → recognize → brute force → optimize → implement → communicate). We're not going to belabor the structure. Instead, we're going to spend our time on the **actual mental moves** within each phase — the thinking that beginners skip and seniors do automatically. ## What we're doing here You're given two sorted integer ar
LeetCode #15 — 3Sum, Walked Through the Six-Phase Framework
3mo ago · 21:04
You're given an array and asked to find all unique triplets `(a, b, c)` where `a + b + c = 0`. Naive: three nested loops, O(n³). NeetCode's optimal: **sort the array, then for each `a`, run two pointers on the rest looking for `b + c = -a`**. O(n²) total. The clever parts are (1) sorting first to enable two pointers and (2) carefully skipping duplicates at three levels to avoid duplicate triplets in the output. 3Sum is **sort + two-pointer**, with three de-duplication skips. NeetCode's canonical approach is the keystone of the Two Pointers category. **The pattern composes: sorting enables two-
LeetCode #3 — Longest Substring Without Repeating Characters, Walked Through the Six-Phase Framework
3mo ago · 17:41
Whenever a problem asks for the longest (or shortest) **subarray or substring** with some property, the answer is **sliding window**. Two pointers — `left` and `right` — define a window over the input. The right pointer expands the window; when the property breaks, the left pointer shrinks until the property holds again. NeetCode's canonical approach uses a **hashset** to track unique characters and shrinks the window from the left until the duplicate is gone. Longest Substring Without Repeating Characters is the **canonical sliding window**. Two pointers, a hashset, one pass. The window grows
LeetCode #121 — Best Time to Buy and Sell Stock, Walked Through the Six-Phase Framework
3mo ago · 16:22
You're given a list of stock prices and you need to find the maximum profit from buying once and selling once on a later day. The brute force is O(n²) — try every (buy, sell) pair. The optimization: as you walk the array, **maintain the minimum price seen so far**. At each day, the best possible profit *if you sold today* is `current_price - min_so_far`. Track the maximum across all days. **One pass, two running variables, done.** Best Time to Buy and Sell Stock is the **prototype of the running-state pattern**. Maintain a small number of running variables that summarize "everything seen so fa
LeetCode #20 — Valid Parentheses, Walked Through the Six-Phase Framework
3mo ago · 19:10
Whenever a problem involves **matching pairs that nest** — parentheses, function calls, undo/redo, HTML tags — the answer is a stack. The stack remembers what's still "open" so you can match the next "close" against the most recent open. **The pattern is "last opened, first closed" = LIFO = stack.** Get this once and you transfer it to the next dozen stack problems instantly. Valid Parentheses is the **introduction to the Stack pattern**. Stack remembers the most recent unclosed open; LIFO matches the nesting structure of brackets. The close-to-open hashmap collapses the comparison into one li
LeetCode #125 — Valid Palindrome, Walked Through the Six-Phase Framework
3mo ago · 16:25
A palindrome reads the same forwards and backwards. The naive way is to reverse the string and compare. The optimal way is to walk two pointers from the ends inward, comparing characters. The two-pointer pattern is the single most common alternative to hashmap when the data has natural "structure from both ends" — symmetry, sortedness, monotonicity. **Two pointers is what you reach for when the problem has structure but doesn't need memory.** Valid Palindrome is **the introduction to the two-pointer pattern**. Two pointers from both ends, moving inward, comparing as they go, with skip-logic fo
LeetCode #238 — Product of Array Except Self, Walked Through the Six-Phase Framework
3mo ago · 17:00
This problem looks like it should be solved with division (compute total product, divide by each element). But the problem explicitly *forbids* division. That constraint forces you to invent the prefix/suffix product pattern: for each index, the answer is "everything to my left, multiplied by everything to my right." Build those two products in two linear passes — done. Product of Array Except Self introduces the **prefix/suffix array** pattern. Whenever the answer at each position depends on "everything to the left" or "everything to the right," build those two products (or sums, or maxes) in
LeetCode #347 — Top K Frequent Elements, Walked Through the Six-Phase Framework
3mo ago · 13:18
Top K Frequent reduces to a two-step pipeline: (1) count occurrences with a hashmap, (2) extract the top k counts using a selection algorithm. The whole interesting decision is *how* you do step 2 — heap, full sort, or bucket sort. **Bucket sort is the optimal answer; heap is the standard interview answer; full sort is the brute force.** Knowing all three and articulating the tradeoff is the senior move. Top K Frequent is **count + select**. Counting is the hashmap pattern. Selection has three flavors: full sort (brute force), heap (standard), bucket sort (optimal when frequency range is bound

Episodes

Reading the feed…

More Technology shows

Code With Wilson

Episodes 45

The Launch Tax: How CUDA Graphs Keep Your GPU From Sitting Idle

The Model Is a Commodity: What an AI Engineer Actually Builds

Attention Is Just Four Operations: How Every LLM Decides What to Read

Serving Is a Separate Problem: How vLLM Runs LLMs Fast and Cheap

Learn to Drive Before You Study the Engine: The fast.ai Bet on Top-Down Deep Learning

One Camera, One 3D World: How a Feed-Forward Model Rebuilds a Room at 20 Frames a Second

What a Production Agent Framework Actually Gives You: The Anatomy of Agno

When Two AI Models Shake Hands: The Whisk-to-Veo Pipeline

Three Axes and Two Heresies: How Open Models Are Catching the Frontier

Agent Swarms: Why One Smart Model Averages Away the Answer

How Computers Read Code: Compilers, Machine Code, and the Call Stack

Architecture in the Middle: ISA vs Microarchitecture, and Why It Matters When You Build With AI

The 671-Billion-Parameter Model That Fits on One Gaming GPU

What Actually Gets Senior Engineers Hired: Reasoning Under Constraints

LeetCode #169 — Majority Element: How to Actually Think About It

LeetCode #26 — Remove Duplicates from Sorted Array: How to Actually Think About It

LeetCode #27 — Remove Element: How to Actually Think About It

LeetCode #88 — Merge Sorted Array: How to Actually Think About It

LeetCode #15 — 3Sum, Walked Through the Six-Phase Framework

LeetCode #3 — Longest Substring Without Repeating Characters, Walked Through the Six-Phase Framework

LeetCode #121 — Best Time to Buy and Sell Stock, Walked Through the Six-Phase Framework

LeetCode #20 — Valid Parentheses, Walked Through the Six-Phase Framework

LeetCode #125 — Valid Palindrome, Walked Through the Six-Phase Framework

LeetCode #238 — Product of Array Except Self, Walked Through the Six-Phase Framework

LeetCode #347 — Top K Frequent Elements, Walked Through the Six-Phase Framework

Episodes

More Technology shows

AppleVis Podcast

Material

Área de Transferência

Super Feed

Don't Panic

HTML All The Things - Web Development, AI, and Developer Careers

Episodes 45

The Launch Tax: How CUDA Graphs Keep Your GPU From Sitting Idle

The Model Is a Commodity: What an AI Engineer Actually Builds

Attention Is Just Four Operations: How Every LLM Decides What to Read

Serving Is a Separate Problem: How vLLM Runs LLMs Fast and Cheap

Learn to Drive Before You Study the Engine: The fast.ai Bet on Top-Down Deep Learning

One Camera, One 3D World: How a Feed-Forward Model Rebuilds a Room at 20 Frames a Second

What a Production Agent Framework Actually Gives You: The Anatomy of Agno

When Two AI Models Shake Hands: The Whisk-to-Veo Pipeline

Three Axes and Two Heresies: How Open Models Are Catching the Frontier

Agent Swarms: Why One Smart Model Averages Away the Answer

How Computers Read Code: Compilers, Machine Code, and the Call Stack

Architecture in the Middle: ISA vs Microarchitecture, and Why It Matters When You Build With AI

The 671-Billion-Parameter Model That Fits on One Gaming GPU

What Actually Gets Senior Engineers Hired: Reasoning Under Constraints

LeetCode #169 — Majority Element: How to Actually Think About It

LeetCode #26 — Remove Duplicates from Sorted Array: How to Actually Think About It

LeetCode #27 — Remove Element: How to Actually Think About It

LeetCode #88 — Merge Sorted Array: How to Actually Think About It

LeetCode #15 — 3Sum, Walked Through the Six-Phase Framework

LeetCode #3 — Longest Substring Without Repeating Characters, Walked Through the Six-Phase Framework

LeetCode #121 — Best Time to Buy and Sell Stock, Walked Through the Six-Phase Framework

LeetCode #20 — Valid Parentheses, Walked Through the Six-Phase Framework

LeetCode #125 — Valid Palindrome, Walked Through the Six-Phase Framework

LeetCode #238 — Product of Array Except Self, Walked Through the Six-Phase Framework

LeetCode #347 — Top K Frequent Elements, Walked Through the Six-Phase Framework