AI Inference
549 episodes · Page 12 of 23
#2551: How Progressive Disclosure Saves MCP from Token Bloat
Why dumping all tool schemas into context breaks accuracy — and three implementations that fix it.
#2546: The Invisible Engineering Behind a Single Click
The technical stack behind click-to-edit features in tools like Canva and Google Photos — from segmentation to inpainting.
#2545: Visual AI Pipelines: Beyond Python Glue Code
From ComfyUI to Dify — a tour of visual tools for building modular AI workflows without writing glue code.
#2543: Why Base64 Adds 33% Overhead (And Why You Still Need It)
Base64 isn’t compression — it’s a safe transport encoding. Here’s how it works with audio APIs and where its limits are.
#2517: How Unsloth Makes LLM Fine-Tuning 2x Faster
Unsloth cuts memory usage by 50-70% and speeds up training 2.2x for models like Llama 3 and Mistral.
#2512: How Speech-to-Speech Models Eliminate the Robot Voice
Why AI voice agents sound robotic, and how natively integrated speech-to-speech models fix it.
#2511: Measuring AI API Latency Through the Black Box
How to benchmark token throughput and debug slowdowns in closed CLI tools like Claude Code using OpenTelemetry and mitmproxy.
#2505: How Self-Hosted Search Actually Works for AI Agents
SearXNG isn't a crawler — it's a metasearch router. Here's how it works and why AI agents change everything.
#2497: Tracing One Python Print Through 6 Abstraction Layers
What actually happens when you print "Hello" in Python? Six layers, 562 system calls, and a hardware-enforced kernel boundary.
#2488: Hybrid Pipelines for Entity Resolution
Classic NLP pipelines vs. lightweight LLMs for handling Hezbollah’s half-dozen spellings.
#2486: Why Noise Reduction Can Ruin Transcription Accuracy
Cleaning audio before transcription can increase errors by up to 46%. Here's the right approach for your voice app.
#2470: Where Intelligence Should Live in Your Pipeline
When should you fine-tune a tiny model for prompt enhancement instead of prompting a large one? The answer depends on latency, precision, and domain.
#2469: Embedding Model Deprecation: RAG's Silent Killer
When OpenAI retires an embedding model, your RAG pipeline breaks silently. Here’s how to fix it.
#2468: When Tokens Meet GPU Seconds
How to track AI spend across Open Router, Replicate, and more — without a unified dashboard.
#2467: The Time Tax on API Access
How OpenAI and Anthropic structure API tiers, rate limits, and why your billing history matters more than you think.
#2464: Batch APIs: The 50% Discount You're Probably Misusing
Batch inference APIs offer 50% off — but only for the right workloads. Here's when they actually make sense.
#2461: How Claude Code's Conversation Compaction Actually Works
The three-tier system, what survives, what dies, and why you shouldn't rely on auto-compact.
#2458: Can Graph Databases Go Mainstream?
Graph databases are powerful but niche. Will they ever power mainstream CRMs and ERPs?
#2456: Choosing Between AI Cloud Providers
A practical guide to choosing between Modal, RunPod, Nebius, and Baseten for AI workloads.
#2442: Why Enterprises Choose AWS Bedrock Over Direct AI APIs
The real reasons behind the cloud intermediary's dominance in enterprise AI inference.
#2432: The Hidden Cost of Flexibility in Chip Design
The economics and engineering of ASICs vs. CPUs and GPUs, from transistor placement to hyperscaler strategy.
#2431: The 3 Markets in an AI Trench Coat
GPUs, LPUs, and ASICs: why the best hardware for AI depends entirely on what you're trying to do.
#2426: Why DeepSeek V4's Prose Feels More Vivid Than Claude or GPT
A million-token context window at 2% the KV-cache cost — and prose that actually breathes. Here's what makes V4 different.
#2408: How Backpropagation Actually Unlocks Neural Networks
How error signals flow backward through networks to make learning possible — and why "it's just calculus" misses the point.