Podcast
Vanishing Gradients
Hosted by Hugo Bowne-Anderson · EN
A podcast for people who build with AI. Long-format conversations with people shaping the field about agents, evals, multimodal systems, data infrastructure, and the tools behind them. Guests include Jeremy Howard (fast.ai), Hamel Husain (Parlance Labs), Shreya Shankar (UC Berkeley), Wes McKinney (creator of pandas), Samuel Colvin (Pydantic) and more.
hugobowne.substack.com
hugobowne.substack.com
32episodes
Episodes
Newest firstAll episodes
Episode 62: Practical AI at Work: How Execs and Developers Can Actually Use LLMs
Oct 3100:59:04Tap to summarizeMany leaders are trapped between chasing ambitious, ill-defined AI projects and the paralysis of not knowing where to start. Dr. Randall Olson argues that the real opportunity isn't in moonshots, but in the "trillions of dollars of business value" available right now. As co-founder of Wyrd Studios, he bridges the gap between data science, AI engineering, and executive strategy to deliver a practical framework for execution.In this episode, Randy and Hugo lay out how to find and solve what might be considered "boring but valuable" problems, like an EdTech company automating 20% of its support tickets with a simple retrieval bot instead of a complex AI tutor. They discuss how to move incrementally along the "agentic spectrum" and why treating AI evaluation with the same rigor as software engineering is non-negotiable for building a disciplined, high-impact AI strategy.They talk through:How a non-technical leader can prototype a complex insurance claim classifier using just photos and a ChatGPT subscription.The agentic spectrum: Why you should start by automating meeting summaries before attempting to build fully autonomous agents.The practical first step for any executive: Building a personal knowledge base with meeting transcripts and strategy docs to get tailored AI advice.Why treating AI evaluation with the same rigor as unit testing is essential for shipping reliable products.The organizational shift required to unlock long-term AI gains, even if it means a short-term productivity dip.LINKSRandy on LinkedIn (https://www.zenml.io/llmops-database)Wyrd Studios (https://thewyrdstudios.com/)Stop Building AI Agents (https://www.decodingai.com/p/stop-building-ai-agents)Upcoming Events on Luma (https://lu.ma/calendar/cal-8ImWFDQ3IEIxNWk)Watch the podcast video on YouTube (https://youtu.be/-YQjKH3wRvc)🎓 Learn more:In Hugo's course: Building AI Applications for Data Scientists and Software Engineers (https://maven.com/hugo-stefan/building-llm-apps-ds-and-swe-from-first-principles?promoCode=AI20) — https://maven.com/hugo-stefan/building-llm-apps-ds-and-swe-from-first-principles?promoCode=AI20 Next cohort starts November 3: come build with us! This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit hugobowne.substack.com
Transcribe →
Episode 60: 10 Things I Hate About AI Evals with Hamel Husain
Sep 3001:13:15Tap to summarizeMost AI teams find "evals" frustrating, but ML Engineer Hamel Husain argues they’re just using the wrong playbook. In this episode, he lays out a data-centric approach to systematically measure and improve AI, turning unreliable prototypes into robust, production-ready systems. Drawing from his experience getting countless teams unstuck, Hamel explains why the solution requires a "revenge of the data scientists." He details the essential mindset shifts, error analysis techniques, and practical steps needed to move beyond guesswork and build AI products you can actually trust. We talk through: The 10(+1) critical mistakes that cause teams to waste time on evals Why "hallucination scores" are a waste of time (and what to measure instead) The manual review process that finds major issues in hours, not weeks A step-by-step method for building LLM judges you can actually trust How to use domain experts without getting stuck in endless review committees Guest Bryan Bischof's "Failure as a Funnel" for debugging complex AI agents If you're tired of ambiguous "vibe checks" and want a clear process that delivers real improvement, this episode provides the definitive roadmap. LINKS Hamel's website and blog Hugo speaks with Philip Carter (Honeycomb) about aligning your LLM-as-a-judge with your domain expertise Hamel Husain on Lenny's pocast, which includes a live demo of error analysis The episode of VG in which Hamel and Hugo talk about Hamel's "data consulting in Vegas" era Upcoming Events on Luma Watch the podcast video on YouTube Hamel's AI evals course, which he teaches with Shreya Shankar (UC Berkeley): starts Oct 6 and this link gives 35% off! https://maven.com/parlance-labs/evals?promoCode=GOHUGORGOHOME 🎓 Learn more: Hugo's course: Building LLM Applications for Data Scientists and Software Engineers — https://maven.com/s/course/d56067f338
Transcribe →Episode 59: Patterns and Anti-Patterns For Building with AI
Sep 2300:47:37Tap to summarizeJohn Berryman (Arcturus Labs; early GitHub Copilot engineer; co-author of Relevant Search and Prompt Engineering for LLMs) has spent years figuring out what makes AI applications actually work in production. In this episode, he shares the “seven deadly sins” of LLM development — and the practical fixes that keep projects from stalling. From context management to retrieval debugging, John explains the patterns he’s seen succeed, the mistakes to avoid, and why it helps to think of an LLM as an “AI intern” rather than an all-knowing oracle. We talk through: Why chasing perfect accuracy is a dead end How to use agents without losing control Context engineering: fitting the right information in the window Starting simple instead of over-orchestrating Separating retrieval from generation in RAG Splitting complex extractions into smaller checks Knowing when frameworks help — and when they slow you down A practical guide to avoiding the common traps of LLM development and building systems that actually hold up in production. LINKS: Context Engineering for AI Agents, a free, upcoming lightning lesson from John and Hugo The Hidden Simplicity of GenAI Systems, a previous lightning lesson from John and Hugo Roaming RAG – RAG without the Vector Database, by John Cut the Chit-Chat with Artifacts, by John Prompt Engineering for LLMs by John and Albert Ziegler Relevant Search by John and Doug Turnbull Arcturus Labs Watch the podcast on YouTube Upcoming Events on Luma 🎓 Learn more: Hugo's course (this episode was a guest Q&A from the course): Building LLM Applications for Data Scientists and Software Engineers — https://maven.com/s/course/d56067f338
Transcribe →Episode 58: Building GenAI Systems That Make Business Decisions with Thomas Wiecki (PyMC Labs)
Sep 901:00:45Tap to summarizeWhile most conversations about generative AI focus on chatbots, Thomas Wiecki (PyMC Labs, PyMC) has been building systems that help companies make actual business decisions. In this episode, he shares how Bayesian modeling and synthetic consumers can be combined with LLMs to simulate customer reactions, guide marketing spend, and support strategy. Drawing from his work with Colgate and others, Thomas explains how to scale survey methods with AI, where agents fit into analytics workflows, and what it takes to make these systems reliable. We talk through: Using LLMs as “synthetic consumers” to simulate surveys and test product ideas How Bayesian modeling and causal graphs enable transparent, trustworthy decision-making Building closed-loop systems where AI generates and critiques ideas Guardrails for multi-agent workflows in marketing mix modeling Where generative AI breaks (and how to detect failure modes) The balance between useful models and “correct” models If you’ve ever wondered how to move from flashy prototypes to AI systems that actually inform business strategy, this episode shows what it takes. LINKS: The AI MMM Agent, An AI-Powered Shortcut to Bayesian Marketing Mix Insights AI-Powered Decision Making Under Uncertainty Workshop w/ Allen Downey & Chris Fonnesbeck (PyMC Labs) The Podcast livestream on YouTube Upcoming Events on Luma 🎓 Learn more: Hugo's course: Building LLM Applications for Data Scientists and Software Engineers — https://maven.com/s/course/d56067f338
Transcribe →Episode 57: AI Agents and LLM Judges at Scale: Processing Millions of Documents (Without Breaking the Bank)
Aug 2900:41:27Tap to summarizeWhile many people talk about “agents,” Shreya Shankar (UC Berkeley) has been building the systems that make them reliable. In this episode, she shares how AI agents and LLM judges can be used to process millions of documents accurately and cheaply. Drawing from work on projects ranging from databases of police misconduct reports to large-scale customer transcripts, Shreya explains the frameworks, error analysis, and guardrails needed to turn flaky LLM outputs into trustworthy pipelines. We talk through: Treating LLM workflows as ETL pipelines for unstructured text Error analysis: why you need humans reviewing the first 50–100 traces Guardrails like retries, validators, and “gleaning” How LLM judges work — rubrics, pairwise comparisons, and cost trade-offs Cheap vs. expensive models: when to swap for savings Where agents fit in (and where they don’t) If you’ve ever wondered how to move beyond unreliable demos, this episode shows how to scale LLMs to millions of documents — without breaking the bank. LINKS Shreya's website DocETL, A system for LLM-powered data processing Upcoming Events on Luma Watch the podcast video on YouTube Shreya's AI evals course, which she teaches with Hamel "Evals" Husain 🎓 Learn more: Hugo's course: Building LLM Applications for Data Scientists and Software Engineers — https://maven.com/s/course/d56067f338
Transcribe →Episode 56: DeepMind Just Dropped Gemma 270M... And Here’s Why It Matters
Aug 1400:45:40Tap to summarizeWhile much of the AI world chases ever-larger models, Ravin Kumar (Google DeepMind) and his team build across the size spectrum, from billions of parameters down to this week’s release: Gemma 270M, the smallest member yet of the Gemma 3 open-weight family. At just 270 million parameters, a quarter the size of Gemma 1B, it’s designed for speed, efficiency, and fine-tuning. We explore what makes 270M special, where it fits alongside its billion-parameter siblings, and why you might reach for it in production even if you think “small” means “just for experiments.” We talk through: Where 270M fits into the Gemma 3 lineup — and why it exists On-device use cases where latency, privacy, and efficiency matter How smaller models open up rapid, targeted fine-tuning Running multiple models in parallel without heavyweight hardware Why “small” models might drive the next big wave of AI adoption If you’ve ever wondered what you’d do with a model this size (or how to squeeze the most out of it) this episode will show you how small can punch far above its weight. LINKS Introducing Gemma 3 270M: The compact model for hyper-efficient AI (Google Developer Blog) Full Model Fine-Tune Guide using Hugging Face Transformers The Gemma 270M model on HuggingFace The Gemma 270M model on Ollama Building AI Agents with Gemma 3, a workshop with Ravin and Hugo (Code here) From Images to Agents: Building and Evaluating Multimodal AI Workflows, a workshop with Ravin and Hugo(Code here) Evaluating AI Agents: From Demos to Dependability, an upcoming workshop with Ravin and Hugo Upcoming Events on Luma Watch the podcast video on YouTube 🎓 Learn more: Hugo's course: Building LLM Applications for Data Scientists and Software Engineers — https://maven.com/s/course/d56067f338 ($600 off early bird discount for November cohort availiable until August 16)
Transcribe →Episode 55: From Frittatas to Production LLMs: Breakfast at SciPy
Aug 12, 202500:38:08Tap to summarizeTraditional software expects 100% passing tests. In LLM-powered systems, that’s not just unrealistic — it’s a feature, not a bug. Eric Ma leads research data science in Moderna’s data science and AI group, and over breakfast at SciPy we explored why AI products break the old rules, what skills different personas bring (and miss), and how to keep systems alive after the launch hype fades. You’ll hear the clink of coffee cups, the murmur of SciPy in the background, and the occasional bite of frittata as we talk (hopefully also a feature, not a bug!) We talk through: • The three personas — and the blind spots each has when shipping AI systems • Why “perfect” tests can be a sign you’re testing the wrong thing • Development vs. production observability loops — and why you need both • How curiosity about failing data separates good builders from great ones • Ways large organizations can create space for experimentation without losing delivery focus If you want to build AI products that thrive in the messy real world, this episode will help you embrace the chaos — and make it work for you. LINKS Eric' Website More about the workshops Eric and Hugo taught at SciPy Upcoming Events on Luma 🎓 Learn more: Hugo's course: Building LLM Applications for Data Scientists and Software Engineers — https://maven.com/s/course/d56067f338 ($600 off early bird discount for November cohort availiable until August 16)
Transcribe →Episode 54: Scaling AI: From Colab to Clusters — A Practitioner’s Guide to Distributed Training and Inference
Jul 18, 202500:41:17Tap to summarizeColab is cozy. But production won’t fit on a single GPU. Zach Mueller leads Accelerate at Hugging Face and spends his days helping people go from solo scripts to scalable systems. In this episode, he joins me to demystify distributed training and inference — not just for research labs, but for any ML engineer trying to ship real software. We talk through: • From Colab to clusters: why scaling isn’t just about training massive models, but serving agents, handling load, and speeding up iteration • Zero-to-two GPUs: how to get started without Kubernetes, Slurm, or a PhD in networking • Scaling tradeoffs: when to care about interconnects, which infra bottlenecks actually matter, and how to avoid chasing performance ghosts • The GPU middle class: strategies for training and serving on a shoestring, with just a few cards or modest credits • Local experiments, global impact: why learning distributed systems—even just a little—can set you apart as an engineer If you’ve ever stared at a Hugging Face training script and wondered how to run it on something more than your laptop: this one’s for you. LINKS Zach on LinkedIn Hugo's blog post on Stop Buliding AI Agents Upcoming Events on Luma Hugo's recent newsletter about upcoming events and more! 🎓 Learn more: Hugo's course: Building LLM Applications for Data Scientists and Software Engineers — https://maven.com/s/course/d56067f338 Zach's course (45% off for VG listeners!): Scratch to Scale: Large-Scale Training in the Modern World -- https://maven.com/walk-with-code/scratch-to-scale?promoCode=hugo39 📺 Watch the video version on YouTube: YouTube link
Transcribe →Episode 53: Human-Seeded Evals & Self-Tuning Agents: Samuel Colvin on Shipping Reliable LLMs
Jul 8, 202500:44:49Tap to summarizeDemos are easy; durability is hard. Samuel Colvin has spent a decade building guardrails in Python (first with Pydantic, now with Logfire), and he’s convinced most LLM failures have nothing to do with the model itself. They appear where the data is fuzzy, the prompts drift, or no one bothered to measure real-world behavior. Samuel joins me to show how a sprinkle of engineering discipline keeps those failures from ever reaching users. We talk through: • Tiny labels, big leverage: how five thumbs-ups/thumbs-downs are enough for Logfire to build a rubric that scores every call in real time • Drift alarms, not dashboards: catching the moment your prompt or data shifts instead of reading charts after the fact • Prompt self-repair: a prototype agent that rewrites its own system prompt—and tells you when it still doesn’t have what it needs • The hidden cost curve: why the last 15 percent of reliability costs far more than the flashy 85 percent demo • Business-first metrics: shipping features that meet real goals instead of chasing another decimal point of “accuracy” If you’re past the proof-of-concept stage and staring down the “now it has to work” cliff, this episode is your climbing guide. LINKS Pydantic Logfire Upcoming Events on Luma Hugo's recent newsletter about upcoming events and more! 🎓 Learn more: Hugo's course: Building LLM Applications for Data Scientists and Software Engineers — next cohort starts July 8: https://maven.com/s/course/d56067f338 📺 Watch the video version on YouTube: YouTube link
Transcribe →Episode 52: Why Most LLM Products Break at Retrieval (And How to Fix Them)
Jul 2, 202500:28:38Tap to summarizeMost LLM-powered features do not break at the model. They break at the context. So how do you retrieve the right information to get useful results, even under vague or messy user queries? In this episode, we hear from Eric Ma, who leads data science research in the Data Science and AI group at Moderna. He shares what it takes to move beyond toy demos and ship LLM features that actually help people do their jobs. We cover: • How to align retrieval with user intent and why cosine similarity is not the answer • How a dumb YAML-based system outperformed so-called smart retrieval pipelines • Why vague queries like “what is this all about” expose real weaknesses in most systems • When vibe checks are enough and when formal evaluation is worth the effort • How retrieval workflows can evolve alongside your product and user needs If you are building LLM-powered systems and care about how they work, not just whether they work, this one is for you. LINKS Eric's website Upcoming Events on Luma Hugo's recent newsletter about upcoming events and more! 🎓 Learn more: Hugo's course: Building LLM Applications for Data Scientists and Software Engineers — next cohort starts July 8: https://maven.com/s/course/d56067f338 📺 Watch the video version on YouTube: YouTube link
Transcribe →