RAG Isn't Dead, You're Just New Here

Tim Williams: [inhale] Hey there, Rubber Ducklings — welcome back to Rubber Duck Radio. I'm Tim Williams... Paul Mason: And I'm Paul Mason. [short pause] Episode fifteen! [chuckle] You know, by episode fifteen you'd think we'd run out of things to be annoyed about. And yet — [tsk] the internet just keeps providing. Tim Williams: [laughs] The well of frustration is deep and endlessly renewable. It's like geothermal energy, but for opinions. [inhale] So how was your week, Paul? What's got you fired up? Paul Mason: [exhale] You know — [short pause] I spent way too much time on Twitter this week. Are we still calling it twitter? [laugh] Like, the kind of doom-scrolling where you read a take and think... [pause] have you [emphasis] actually used this thing? Or are you just, like, summarizing someone else's summary of a blog post they skimmed? Tim Williams: [chuckle] Oh, I know [emphasis] exactly the takes you're talking about. [inhale] And honestly? This has been living in my head rent-free for weeks now. [pause] I've realized I can tell exactly where someone is on the AI learning curve — I mean [emphasis] precisely — based on what they complain about on X. Paul Mason: [laughing] Oh, this is gonna be good. [short pause] Go on. Lay out the taxonomy. Tim Williams: [inhale] I'm serious though. [pause] You see someone post 'RAG is dead' or 'MCP is over' — and before you even read the rest of the thread, you already know [emphasis] exactly what stage they're at. It's like a diagnostic tool. Better than any benchmark. [chuckle] And the thing is... [pause] they're not entirely wrong. But they're wrong in the [emphasis] specific way that tells you they're standing at mile marker two of a marathon and declaring the race is over. Paul Mason: [exhale] Okay. [short pause] So we're doing this. We're doing the 'I can tell where you are on the Dunning-Kruger curve based on your AI hot takes' episode. [chuckle] I'm here for it. Tim Williams: [laughs] We are [emphasis] absolutely doing this. [inhale] Because RAG isn't dead. MCP isn't dead. But if you think they are — [pause] that tells me something very specific about your experience with them. And it's almost always the [emphasis] same story. [short pause] So today we're gonna break down what RAG and MCP actually are, why they're so widely misunderstood, and — more importantly — [emphasis] why the people declaring them dead are usually standing on first base thinking they hit a home run. Paul Mason: Alright. [laughing] So we're starting with RAG then? Because I've got — [short pause] I've got [emphasis] thoughts. From the trenches. Some of them learned the hard way, as usual. Tim Williams: [inhale] Let's do it. But first — [pause] let me set the stage. Because you can't understand why the hot takes are wrong until you understand [emphasis] what people are actually getting wrong. And the pattern is so predictable, Paul — [chuckle] I could practically build a flowchart. Paul Mason: yeah? [chuckle] Tim Williams: [inhale] Here's the thing. [pause] When most people say 'RAG,' what they're picturing is [emphasis] one very specific implementation. User asks a question. You run a vector search against some chunked documents. You grab the top three or five results. You stuff them into the system prompt. The LLM synthesizes an answer. [short pause] That's it. That's the whole mental model. [exhale] And look — that [emphasis] works. For a certain class of problems, at a certain scale, it's genuinely useful. Nobody's arguing that. Tim Williams: [inhale] But here's where the learning curve tell kicks in. [pause] If you think that's [emphasis] all RAG is — if you think retrieval-augmented generation is synonymous with 'vector search plus prompt stuffing' — then of [emphasis] course you're gonna hit a wall. Of course you're gonna declare it dead. Because you built the Hello World version and then tried to use it in production. [chuckle] And when it failed — badly, as it should have — you didn't think 'I need to go deeper.' You thought 'the whole paradigm is broken.' Tim Williams: [inhale] Let's actually dissect the term. [pause] Retrieval. Augmented. Generation. [short pause] Three words. And each one — [emphasis] each one — opens up an enormous design space that the 'RAG is dead' crowd has usually never explored. Tim Williams: [emphasis] Retrieval. [inhale] That doesn't just mean vector search. Retrieval is — [pause] how do you get the [emphasis] right information into the context window? That could be vector search, sure. But it could also be keyword search, hybrid search, structured queries against a database, API calls, graph traversal, recursive retrieval, agentic retrieval where the model decides [emphasis] what to retrieve and when. [short pause] The retrieval step alone is an entire engineering discipline. And you haven't even gotten to the other two words yet. Paul Mason: In other words, literally every agent and chat platform has a retrieval layer unless it's working exclusively from its training data, which is nearly useless. Tim Williams: [emphasis] Augmented. [inhale] This isn't just 'add the search results to the prompt.' Augmentation covers [pause] reranking, filtering, summarization, citation tracking, chunking strategies, metadata enrichment, multi-step reasoning where retrieval results from step one inform what you retrieve in step two — [short pause] I mean, the augmentation layer is where all the [emphasis] craft lives. It's the difference between 'here's some stuff I found' and 'here's the [emphasis] precise context you need to answer this question correctly.' Tim Williams: [emphasis] Generation. [short pause] Even that's not as simple as people think. Because the generation quality is entirely dependent on the first two steps. Garbage retrieval, garbage augmentation — garbage output. [inhale] So when someone says 'RAG is dead,' what they usually mean is — [pause] 'I tried the simplest possible version of retrieval, I didn't do any augmentation to speak of, and the generation was bad.' [chuckle] Yeah. [emphasis] Obviously. Paul Mason: [exhale] Okay, so — [short pause] I feel [emphasis] seen right now. [chuckle] Because I've been on both sides of this. I've built the simple version — 'oh cool, I'll just chunk these docs, throw 'em in Pinecone, and magic happens' — [tsk] and then I've also been the person debugging that six months later going, [angry] 'why is this returning completely irrelevant stuff?' Tim Williams: [inhale] Alright. So that's RAG. [pause] Now let's talk about MCP. Because the learning curve tell on MCP is — [short pause] honestly, it's even sharper. And I see it constantly. Tim Williams: [inhale] Here's what happens. [pause] Someone discovers MCP. They think — 'this is amazing, I can give my agent access to everything.' So they wire up twenty tools. GitHub API, Slack, their database, Jira, email — [chuckle] all of it. And for about five minutes, it feels like magic. [short pause] And then the agent gets [emphasis] dumb. Like, noticeably dumber. Starts forgetting things. Starts hallucinating tools it doesn't even have. Paul Mason: Yes! I've been there. Right after MCP got hot in 2025. Tim Williams: [exhale] And the reason is — [pause] context window pollution. [inhale] When you stuff the system prompt with twenty tool definitions — each with parameter schemas, descriptions, examples — you're eating a [emphasis] massive chunk of the context window before the conversation even starts. The agent has less working memory for the actual task. [short pause] So it gets confused. It loses the thread. It tries to call tools that don't make sense for the current problem. Tim Williams: [chuckle] And here's where the learning curve tell happens. [pause] The developer hits this wall and thinks — [emphasis] 'MCP is broken.' Or worse, 'MCP is dead.' [inhale] When what they've actually discovered is that context windows are finite and tool selection needs to be intentional. That's not an MCP problem. That's a [emphasis] system design problem. Tim Williams: [exhale] Yeah, and this is where the pushback has gotten really interesting. [inhale] So the counter-argument that's gained traction is — [pause] 'just let the agent write code instead.' Give it primitives — Linux commands, CLI access, basic file system operations — and let the agent [emphasis] compose exactly what it needs. Instead of twenty predefined tools, it writes a script. [short pause] And honestly? For a lot of use cases, this is [emphasis] genuinely better. More flexible. More precise. Less context pollution. Tim Williams: [inhale] But — [pause] here's where the 'MCP is dead' crowd makes their mistake. [emphasis] They assume every agent has access to a CLI. They assume every environment is a Linux box where the agent can just — [chuckle] spin up a subprocess and do its thing. Tim Williams: [emphasis] That's not the world most software lives in. [inhale] Think about an agent embedded in a SaaS product. Think about an agent that needs to interact with third-party APIs that require OAuth — with specific scopes, rate limits, and audit trails. Think about enterprise environments where the agent [emphasis] shouldn't have raw CLI access — it should have scoped, auditable, authenticated access to specific capabilities. [pause] That's exactly what MCP was designed for. Tim Williams: [exhale] So here's the balanced take. [pause] CLI-first agent workflows are [emphasis] powerful. For the right use case — development, system administration, anything where the agent is operating in an environment it fully controls — letting it write code against primitives is elegant. Fewer tools, less context pollution, more flexibility. [short pause] But MCP isn't dead just because CLI workflows exist. [emphasis] MCP is the right tool when you need authenticated, scoped, auditable access to external capabilities. Tim Williams: [inhale] The only [emphasis] wrong point of view — [pause] and this is what drives me up the wall — is the dogmatic one. [short pause] 'MCP is dead.' 'CLI is a toy.' 'Never use tools.' 'Always use tools.' [exhale] It's the same pattern we saw with RAG. Someone hit a limitation, overfit to their specific experience, and declared the entire paradigm obsolete. [pause] That's not engineering. That's — [laughing] that's vibes-based architecture. Paul Mason: [laughing] 'Vibes-based architecture.' [pause] I'm stealing that. [inhale] But yeah — [short pause] I've built systems both ways. And the thing is, [emphasis] neither one is universally right. I've had projects where CLI access was perfect — the agent could inspect the codebase, run tests, check logs. Clean, simple, powerful. [short pause] And I've had projects where we needed — [emphasis] needed — the structured tool definitions and auth layer that MCP provides. Because you can't just hand an agent root access to a production SaaS platform and say 'figure it out.' Paul Mason: [chuckle] So, [inhale] speaking of CLI workflows — [short pause] I've gotta share something I stumbled into recently. And I'm probably late to the party on this, but — [pause] it's been a genuine game changer for how I work with agents. Tim Williams: [intrigued] Oh? What'd you find? Paul Mason: tmux. [short pause] Yeah, I know — [chuckle] I can hear every senior engineer listening right now going 'congratulations, you discovered terminal multiplexers, welcome to 1995.' But hear me out. Tim Williams: [laughing] I mean — [pause] I've been using tmux for years, but [emphasis] please — sell me on why it's new to you. I genuinely want to hear this. Paul Mason: Okay so — [inhale] I was listening to the Syntax podcast — Wes and Scott were talking about their terminal setups — and they mentioned tmux. And I'd heard of it, obviously, but I'd always thought of it as this, like, [short pause] sysadmin thing. You SSH into a server, you run tmux so your session doesn't die. Cool. Whatever. Paul Mason: But then I actually tried it for my local dev workflow. And the thing that clicked — [pause] the thing that made me go [emphasis] 'oh' — was running multiple agent sessions in different panes. Side by side. One agent running tests, another one refactoring a module, and I can [emphasis] watch both of them in real time. Tim Williams: [intrigued] Huh. You know — [short pause] I've used tmux for years but I've never actually thought about it as an [emphasis] agent dashboard. That's interesting. Paul Mason: Right?! And it gets better. [inhale] Because the agents I'm running — they're using CLI tools, right? They're writing code, running commands, checking logs. And with tmux, I can have one window where the agent is working, another window where I'm monitoring the logs it's generating, and a third window where I'm running git diff to see what it actually changed — [pause] all at once. No tab switching. No losing context. Paul Mason: And the killer feature — [short pause] [emphasis] sessions. I can detach from an agent session, go grab lunch, come back, reattach, and everything is exactly where I left it. The agent's still running. The output's still there. [chuckle] It's like — you know how in the Matrix they just jack in and everything's waiting for them? It's that, but for terminal workflows. Tim Williams: [laughing] The Matrix comparison is — [pause] I'll allow it. Barely. [inhale] But you're actually touching on something really important that I don't think enough developers think about. [pause] When you're working with agents — especially when you've got multiple agents doing different things — your [emphasis] environment becomes your interface. And most developers are still treating the terminal like a single-threaded tool. Paul Mason: Exactly! And here's the thing that really sold me — [inhale] I've started using tmux sessions for [emphasis] different contexts. I've got one session for my agent that's doing code review, one for the agent that's writing tests, one for my own manual work. And if I need to switch contexts — boom. Detach, reattach. Done. [short pause] It's like having multiple desktops but for your terminal. Tim Williams: You know what this reminds me of? [inhale] Back when I was first learning Docker, and I realized I could spin up entire environments with one command. That same feeling of — [pause] 'oh, I've been doing this the hard way for years.' [chuckle] I'm happy for you, man. Genuinely. Paul Mason: [laughing] Thank you for not roasting me for being a decade late to tmux. [short pause] But here's my actual point — and this ties back to what we were saying about CLI workflows for agents. [inhale] Tools like tmux make the CLI-first approach [emphasis] viable in a way that just opening five terminal tabs doesn't. It's not the same thing. The persistence, the session management, the ability to organize — [pause] it changes how you think about what's possible. Tim Williams: And that's actually the perfect note to land on. [inhale] Because that's the thread that runs through this whole episode — RAG, MCP, CLI workflows, tmux — [pause] [emphasis] the tools aren't the point. The mental model is the point. [short pause] When someone says 'RAG is dead' or 'MCP is over' or 'tmux is just for sysadmins' — what they're really saying is 'I have a narrow mental model and I stopped exploring.' Paul Mason: [exhale] Yeah. [short pause] That's — that's actually it. That's the whole episode right there. Tim Williams: [chuckle] We should probably wrap it up then. [inhale] Alright, Rubber Ducklings — here's your moral of the story. [pause] The next time you see a hot take declaring that something is dead — whether it's RAG, MCP, or whatever the thing is next week — [short pause] ask yourself: is this paradigm actually dead? Or did this person just hit the limits of their current understanding and confuse that with the limits of the technology? Tim Williams: Because the learning curve is real. We're all on it somewhere. [pause] The difference is whether you treat every wall you hit as a failure of the entire approach — [short pause] or whether you recognize it as a sign that you've reached the edge of what you know so far, and there's more to learn. Paul Mason: And future you will [emphasis] thank present you for staying curious instead of getting dogmatic. [chuckle] That's mine. I'm keeping that. Tim Williams: [laughs] It's a good one. [inhale] This has been Rubber Duck Radio. I'm Tim Williams — Paul Mason: And I'm Paul Mason. [short pause] Go check out tmux. Seriously. Even if Tim silently judges you for being late to it. Tim Williams: [laughing] No judgment! Only enthusiasm. [pause] See you next time, Ducklings.