The Tools That Got Us Here Won't Get Us There

Tim Williams: [inhale] I'm Tim Williams, and Paul Mason is with me. [short pause] Today: CI/CD pipelines in the age of AI coding. [inhale] Paul, I've got projects where the pipeline takes eight to ten minutes from push to production. And here's the thing — [short pause] there are really good reasons for that. [exhale] But I've also started cheating. [pause] And I want to talk about whether that's smart or stupid. Paul Mason: [chuckle] I'm ready to jump in. [short pause] Uh, we're on episode 16, by the way. [pause] Let's do this! Tim Williams: [inhale] Let me paint the picture. These AWS CodeBuild pipelines — [short pause] every single push runs comprehensive end-to-end tests, unit test suites, the whole thing. Servers get turned over with carefully choreographed precision. [pause] Zero downtime. [emphasis] It's beautiful. [inhale] It's also eight to ten minutes of me sitting there, refreshing the console, [short pause] while an AI agent could have already written the next feature. [exhale] The pipeline was designed for human speed — [short pause] human commit frequency, human PR velocity. [pause] And now we've got agents that generate code faster than the pipeline can validate it. Paul Mason: I think every developer working heavily with AI at this point is feeling this pain. I certainly am. Tim Williams: [inhale] So on some of my smaller projects — the one-or-two-developer projects — [short pause] I've just skipped the CI/CD flow entirely. I'm running local virtualization, local deployment pipelines, pushing straight to production from my machine. [pause] And the speed difference is night and day. [inhale] The agent and I are iterating in seconds instead of minutes. The feedback loop is so tight that [emphasis] you just don't lose momentum. Tim Williams: [chuckle] It feels like cheating because, um, [short pause] it kind of is. Paul Mason: [chuckle] I know that feeling. Tim Williams: [inhale] But here's the trade-off. [pause] That local virtualization approach — [short pause] it won't work for a team of three or more. It won't work for anything that needs the stability and assurance of a real pipeline. [sigh] You're eating your seed corn. [pause] You're trading safety for speed, and you'd better have a plan for when that catches up to you. [inhale] So that's where I am, Paul — stuck between a pipeline that's too slow for AI and a shortcut that's too risky for teams. [pause] What are [emphasis]you seeing? Paul Mason: Yeah, [exhale] I've been in the exact same spot. [short pause] And I'll be honest — I've done the same thing. [chuckle] I've pushed straight to production from my local machine on side projects because waiting eight minutes for a pipeline when the agent just wrote thirty lines of perfectly good code — [short pause] it feels absurd. Paul Mason: But I think the real question isn't whether to keep or ditch the pipeline — [emphasis] it's whether the pipeline as we've always known it even makes sense anymore in the AI era. Tim Williams: Totally. Paul Mason: [inhale] I've been reading about what other teams are doing, and there's this emerging pattern I think of as [emphasis] moving validation left. [short pause] The idea is, catch the dumb stuff before it ever hits CI. Pre-commit hooks that run linting and type-checking in two seconds instead of eight minutes. [inhale] And this one's really interesting — [pause] some AI coding tools are starting to ship lifecycle hooks that run tests [emphasis] inside the agent session itself. So the agent generates code, the hook runs validation, and the agent sees the failure before you even commit. [excited] The feedback loop goes from push-and-wait to before-you-even-push. Tim Williams: [excited] That hooks-into-the-agent thing is huge. [chuckle] It's like giving the AI its own conscience instead of waiting for the CI priest to come down from the mountain and tell you you've sinned. [inhale] But there's another approach I've been seeing — [short pause] making the pipeline itself smarter instead of shorter. Intelligent test selection, where you use AI to figure out which tests are actually relevant to the changed code instead of running everything every time. [pause] CloudBees has data on this — [emphasis] teams are seeing eighty percent reductions in regression testing time. [inhale] One company went from six-hour pre-commit testing to [huge emphasis] two hours. Paul Mason: [chuckle] And here's a related one that's kind of embarrassing — [short pause] about a third of CI failures are flaky. They fail with no underlying code change. Just the test being unreliable. [inhale] So some teams are getting massive capacity back just by identifying and fixing flaky tests, without touching their pipeline architecture at all. [pause] It's the least glamorous fix and probably the highest-ROI one. Paul Mason: But the approach that feels like the real middle ground to me is ephemeral preview environments. [short pause] You spin up a full-stack disposable environment per pull request — looks like production, acts like production, but it's not production. [pause] You get integration testing at production fidelity without touching the production pipeline. And when the PR merges or closes, the environment disappears. [inhale] There's a whole category of tools emerging around this — Northflank, Uffizzi, Porter. Tim Williams: [chuckle] That's clever. My experience with something like that differs though, I used AWS Amplify, and it's NOT fast the moment you get enough services spun up to make a real production application, you're talking ten to fifteen minute deploy times! Tim Williams: But, that pairs really nicely with progressive delivery and feature flags. [inhale] You decouple deployment from release. You ship code dark behind a flag, roll it out gradually, and if something breaks, you kill the flag — [emphasis] not the deploy. [pause] That changes the whole risk calculus of the pipeline. [inhale] The pipeline stops being this do-not-pass-go checkpoint and becomes more of a confidence-builder. You can move faster because a bad deploy hits [emphasis] zero percent of users until you say so. Tim Williams: [sigh] But here's what's keeping me up at night. [pause] The DORA 2025 report actually found a [emphasis] negative relationship between rapid AI adoption and software delivery stability. [inhale] The faster AI writes code, the more pipelines become the bottleneck, and the more teams are tempted to cut corners on testing. [pause] We're literally seeing the industry's quality guardrails strain under the speed AI creates. Paul Mason: Yeah. Paul Mason: [chuckle] and there's this Reddit thread that's been making the rounds — [short pause] someone called it the [emphasis] CI/CD feedback loop from hell. Push, wait eight minutes, see red, fix a typo, repeat. [inhale] And the thread is full of people saying this exact thing — your pipeline time hasn't changed, but your expectations have, because AI is generating code so much faster. [pause] The ratio of coding time to validation time has completely flipped. Paul Mason: [inhale] That team size point you made earlier is the real dividing line though. Local virtualization works great for one or two developers — [short pause] I've done it, you've done it. But at three, five, ten people, [emphasis] you need something shared. [pause] The question isn't whether you need a pipeline at scale — you do. The question is, [short pause] what's the smallest-possible pipeline that still gives you confidence? [exhale] And I don't think anyone has a definitive answer yet. Tim Williams: [short pause] Right. Tim Williams: [inhale] I think that's exactly where we land. [pause] Run everything is dead at AI scale — [short pause] you can't run every test on every commit when AI is generating commits at three times the velocity. [exhale] But nobody's quite sure what replaces it. Every middle ground we've talked about trades [emphasis] some safety for speed. [inhale] Pre-commit hooks miss integration issues. Ephemeral environments add complexity. Intelligent test selection can miss regressions. [pause] The moral of the story is, [short pause] we're in the messy middle, and the dev ecosystem is probably converging on something — [exhale] we just haven't arrived yet. Paul Mason: [inhale] Future you will thank present you for paying attention to this now though. [short pause] Because whether you go the move-validation-left route, the smarter-pipeline route, or some hybrid — [pause] the teams that figure out their CI/CD strategy for the AI era are going to have a massive advantage over the ones still waiting eight minutes for a typo check. [emphasis] It's not the flashiest problem, but it might be the most important one nobody's talking about. Paul Mason: [inhale] Alright, [short pause] speaking of things that are driving people up the wall — [pause] can I throw out a hot take? [chuckle] One that might get me in trouble? Tim Williams: [chuckle] I mean, [short pause] that's basically our brand at this point. [inhale] Go for it. Paul Mason: [inhale] I think Cursor is going to fail. [pause] Not tomorrow! [short pause] but long term, I think they made a bet that's going to sink them. And it's the same bet that made them huge in the first place. Tim Williams: [pause] Okay. [inhale] That's a big one. [short pause] Walk me through it. Paul Mason: [inhale] So here's the thing. Cursor's origin story is that they forked VS Code and added AI on top. [short pause] That was [emphasis] brilliant as a go-to-market move. You could import all your extensions, your key bindings, your themes — [pause] your entire environment migrated in under five minutes. [exhale] No switching cost. That's why they hit a hundred and fifty thousand person waitlist. That's why they went from zero to two billion dollars in annualized revenue in like three years. Paul Mason: But — [pause] that entire product is built on VS Code. [emphasis] And VS Code is Electron. [short pause] It's slow. It starts in three-plus seconds versus Zed's sub-half-second cold launch. It uses six hundred and fifty megs of RAM at idle versus Zed's one eighty. [exhale] Input latency is twelve milliseconds versus two. [pause] And here's the thing that kills me — [inhale] with AI agents generating code at the velocity we just spent fifteen minutes talking about, [emphasis] editor performance matters more than ever. You need an editor that can keep up with the agent, not one that stutters every time you open a large file. Tim Williams: [inhale] Yeah, I agree with all of that. Have you ever opened your battery task bar on OSX when you have cursor running? It doesn't matter whether it's currently being used, it always shows that it's consuming [emphasis] ridiculous resources. Tim Williams: So the argument is — [short pause] the industry is moving past Electron-based editors toward native performance, and Cursor can't follow because they're hard-forked from VS Code. Paul Mason: [emphasis] Exactly. [inhale] And it's not just performance. Microsoft is getting actively hostile to forks — [short pause] as of late 2025 they added code checks to some extensions that prevent them from activating in anything that isn't official VS Code. [pause] So Cursor has to maintain their own fork of the entire VS Code platform, keep up with upstream changes, patch around Microsoft's blocking moves, [exhale] and somehow also compete on AI features with companies that aren't carrying all that baggage. Paul Mason: [inhale] Meanwhile, [short pause] look at the competition! Windsurf supports both VS Code and JetBrains. Copilot works across VS Code, JetBrains, Visual Studio, Neovim — [pause] they're IDE-agnostic. [emphasis] Zed is building AI features into a Rust-based editor that renders at a hundred and twenty frames per second. [exhale] JetBrains has their own AI stack on top of native Java performance. [short pause] None of these are chained to a sinking platform. Tim Williams: [exhale] That's a lot of weight to carry! Tim Williams: Okay, so let me push back on this a bit — [pause] because I think there's more to the story. [short pause] Cursor just shipped Cursor 3, and the agent-first interface? [emphasis] Built from scratch. Not extending the VS Code fork. [inhale] They clearly know this is a problem and they're building an escape hatch. Paul Mason: [chuckle] Yeah, I knew you were gonna bring that up. [inhale] And look, credit where it's due — they see the cliff ahead. [short pause] But the agent-first interface is a [emphasis] layer. The core editor underneath is still Electron, still the VS Code fork. [pause] It's like — [short pause] building a beautiful penthouse on top of a foundation you know is cracking. [exhale] At [emphasis] some point you have to dig up the foundation. Tim Williams: [inhale] That's fair. [pause] But here's my counter — [short pause] two billion dollars in revenue buys a lot of engineering. [emphasis] They could rebuild the core. They've got the resources to do a ground-up rewrite if they need to. Paul Mason: [inhale] They could. [pause] But — [short pause] and this is where my skepticism really lives — [emphasis] would they keep their users through that transition? The entire reason people chose Cursor over switching to a different editor was zero migration friction. If you tell two million developers, hey, we're rebuilding on a new platform, your extensions and themes and key bindings won't carry over — [pause] what percentage of them use that moment to evaluate Zed? Or Windsurf? Or go back to VS Code with Copilot? Paul Mason: [inhale] Their moat is also their trap. [short pause] The thing that made switching [emphasis] to Cursor easy is the same thing that'll make switching [emphasis] away from Cursor easy. [pause] There's no lock-in. [exhale] It's just a VS Code fork with a really good AI layer. And when the underlying platform starts feeling slow next to the competition, [short pause] the AI layer might not be enough to keep people around. Tim Williams: [short pause] Mm. Tim Williams: [sigh] [inhale] You know what I keep coming back to? [pause] This feels like the exact same pattern as the CI/CD conversation we just had. [short pause] A tool that was designed for one era — [emphasis] human-speed development — is suddenly being asked to operate at AI speed. And it's buckling. [inhale] VS Code was built for a world where a human typed a hundred words per minute and stopped to think between functions. [pause] Now we've got agents generating entire files in seconds, and the editor is [emphasis] the bottleneck. Paul Mason: That's exactly it! [inhale] It's the same problem from the other direction. CI/CD can't keep up with how fast AI writes code. [short pause] And the editor can't keep up with how fast AI writes code. [pause] We've got AI going a hundred miles an hour and the entire developer toolchain — [emphasis] editors, pipelines, review processes — is still built for thirty-five. Tim Williams: [inhale] So what's the counter-narrative? [pause] If you're running Cursor, [short pause] what's the play? [exhale] Because I don't think it's as simple as they just die. Paul Mason: Honestly? [pause] I think the play is to become the AI layer and decouple from the editor entirely. [short pause] Stop being a VS Code fork and start being the thing that sits [emphasis] on top of whatever editor you use. [exhale] Kind of like what Copilot already does — but better, more deeply integrated. [pause] The problem is, [short pause] that's a completely different business model. And they'd be chasing Copilot from behind instead of being the category leader in AI-native editing. Tim Williams: [inhale] Right, and they'd lose the thing that makes Cursor feel [emphasis] different. [short pause] Cursor isn't great because it's a VS Code fork with AI bolted on — it's great because the AI is [emphasis] woven into the editor. The tab-to-predict, the inline editing, the agent that understands your entire codebase. [pause] If you separate the AI from the editor, [short pause] you lose the magic. You become a plugin. Paul Mason: [exhale] Yeah. [pause] And that's why I think it's a trap they can't easily escape. [inhale] They're the best at what they do — [emphasis] nobody is disputing that. The product is incredible. But their technical foundation is aging in dog years, and every year they don't fix it, [short pause] the cost of fixing it gets bigger and the window for doing it without hemorrhaging users gets smaller. Tim Williams: [inhale] Let me offer a slightly more optimistic take — [pause] and I want to be clear, I'm not saying you're wrong, but I think there's a path. [short pause] Cursor 3's agent-first interface — even though it's a layer on top of the VS Code fork — could be the bridge. [inhale] They build the new agent-first experience, developers spend more and more time in that interface and less in the traditional editor, [pause] and then eventually the old editor underneath becomes [emphasis] legacy. Something they can replace without anyone noticing because nobody's using it directly anymore. Paul Mason: [chuckle] The ship of Theseus strategy. [inhale] Replace every plank while still sailing. [pause] I mean — [short pause] it could work. [emphasis] If they execute it perfectly. [exhale] But that's a big if. And they're doing it while Microsoft, JetBrains, Zed, and Windsurf are all sprinting in the same direction. Tim Williams: [inhale] You know what this reminds me of? [pause] The IE6 era. [short pause] Microsoft won the browser wars, got to ninety-something percent market share, and then — [emphasis] stopped. They had no incentive to improve. And the underlying architecture was so baked into the product that by the time Firefox and Chrome showed up with real performance, [pause] IE couldn't catch up. It took Microsoft a decade and a complete rewrite to become competitive again. Paul Mason: [low voice] Okay, that's a slightly terrifying analogy. [chuckle] [inhale] But I think it works. VS Code today is where IE was in 2004 — [short pause] dominant, ubiquitous, but the architecture is showing its age and the competition is coming from a completely different direction. [pause] And Cursor, [emphasis] by choice, welded itself to that architecture. Tim Williams: [inhale] Here's the thing though — [short pause] VS Code isn't going to disappear overnight. It's got the extension ecosystem. Tens of thousands of extensions. [pause] That network effect is [emphasis] massive. [exhale] Developers put up with a lot of performance pain before they abandon their tooling. Just ask anyone who still uses Eclipse. Paul Mason: [laughing] Oh god. [exhale] [short pause] Fair point. Eclipse still has users. [inhale] But here's the difference — [pause] Eclipse didn't have a generation of native-performance editors shipping [emphasis] with AI built in, all at the same time. [short pause] The competitive pressure on Cursor right now is unlike anything Eclipse ever faced. Zed isn't just faster — it's faster [emphasis] and it's building AI features. JetBrains isn't just native — it's native [emphasis] and has Junie. [exhale] Cursor is getting squeezed from both sides. Tim Williams: [inhale] So where does this land? [pause] I think we agree on the diagnosis — [short pause] Cursor's VS Code dependency is a real long-term risk. We disagree on the prognosis. [chuckle] You think it's terminal, I think it's treatable. Paul Mason: [chuckle] Fair. [inhale] And honestly I hope you're right. [short pause] I [emphasis] use Cursor. I don't want it to fail. [pause] I just look at the trajectory of editor performance — [exhale] the move from Electron to native, from slow to instant, from extension-dependent to purpose-built — and I see Cursor on the wrong side of every one of those trends. With a codebase that makes it really hard to cross over. Tim Williams: [inhale] The moral of the story might be — [pause] short-term bets that get you explosive growth [emphasis] can also become long-term liabilities. [short pause] And the harder they are to unwind, the more dangerous they are. [exhale] Whether that's a CI/CD pipeline designed for human speed, or an editor architecture designed before AI agents existed. Paul Mason: [inhale] Yeah. [pause] And the frustrating thing is, [short pause] in both cases, the right answer for right now isn't necessarily the right answer for five years from now. [emphasis] And the people making these decisions have to bet on both timelines simultaneously. [exhale] Pick the wrong architecture bet and you're Cursor in 2030. Pick the wrong pipeline strategy and your team can't ship. Paul Mason: [inhale] Okay, so — [pause] let's talk about something that actually happened. [short pause] SpaceX secured an option to buy Cursor. [pause] Sixty billion dollars. [exhale] And before we get into whether that's genius or insane — [short pause] let me lay out what's actually in the deal. Tim Williams: [inhale] Yeah, this was — [pause] this was not on my bingo card. [short pause] SpaceX, which already merged with xAI in February — they've got a $10 billion partnership with Cursor minimum, plus the option to acquire them outright at a $60 billion valuation later this year. [exhale] That's not pocket change. That's a [emphasis] statement. Paul Mason: [inhale] Right. [short pause] And the key piece here — the thing that makes this more than just a big number — is Colossus. [pause] xAI's Memphis supercomputer. Over a million H100 equivalents, largest training cluster on the planet. [short pause] Built in 122 days, which is still absurd every time I say it. [exhale] Cursor's been saying publicly they're bottlenecked by compute. This solves that. Paul Mason: [inhale] But here's the thing — Grok is a product, not an ecosystem. AI coding tools are sticky in a way that chatbots aren't. Every developer who uses Cursor is, in some sense, training their own workflow into it. That's data. That's behavior. That's [emphasis] incredibly valuable if you're trying to build the AI operating system for developers. Tim Williams: [inhale] So you're saying Cursor would be the developer entry point into the xAI ecosystem. [short pause] Not just a code editor — [pause] a distribution channel for Grok, for xAI models, for whatever comes next. Paul Mason: [emphasis] Exactly. [inhale] And the timing is — [short pause] it's almost too perfect. Cursor's sitting there with this existential VS Code fork problem we just spent 20 minutes dissecting. They're staring down the barrel of an architectural rewrite they may or may not survive. [pause] And then SpaceX walks in with the world's largest GPU cluster and a $60 billion valuation. [chuckle] Two of Cursor's product engineering heads already jumped to SpaceX in March, by the way. The integration is [emphasis] already underway. Tim Williams: [sigh] [inhale] Okay, so — [pause] there's a version of this that's genuinely compelling. [short pause] Cursor gets access to Colossus. They can train proprietary code models on 200,000 GPUs that literally no other coding tool can touch. [emphasis] That's a moat. GitHub Copilot's running on Azure, JetBrains Junie is doing whatever they're doing — [short pause] but nobody else has a vertically integrated AI stack with that kind of compute behind it. Cursor could ship models fine-tuned on the world's largest code dataset, with inference running on the same hardware. [inhale] That's a [emphasis] product. Paul Mason: [chuckle] That's the bull case. [inhale] The bear case is — [short pause] Elon has a track record of buying things and, uh, [low voice] not exactly making them better. Tim Williams: [laughing] That is the most diplomatic way you could have possibly said that. [short pause] "Not exactly making them better." Paul Mason: [chuckle] I'm trying to be fair! [inhale] But seriously — look at Twitter. The acquisition was chaotic, the layoffs were brutal, the product direction has been — [short pause] let's call it controversial. If you're a Cursor engineer making $300K a year with great work-life balance in a thriving startup culture, [pause] the prospect of Elon walking through the door is — [exhale] you're updating your resume. [short pause] And that brain drain would be devastating for a product as technically complex as Cursor. Tim Williams: [inhale] There's a deeper problem too. [pause] The thing that makes Cursor great right now — [short pause] the reason developers love it — is that it's opinionated but not dogmatic. It's fast, it's thoughtful, it gets out of your way. [inhale] Elon doesn't do subtle. He does [emphasis] big swings. And I don't know if an AI code editor survives being turned into a big swing. The best tools feel invisible. They don't feel like someone else's strategy. Paul Mason: [inhale] Yeah. [pause] But — [short pause] and I hate that I'm about to argue against myself here — [chuckle] the compute argument is really hard to dismiss right now because it's not theoretical anymore. [inhale] Cursor's current AI models are — they're fine, they're good, but they're not differentiated. Anyone can access Claude, anyone can access GPT. Cursor's value add is the UX, the agent mode, the tab completion. [pause] But now Cursor has access to proprietary models trained on Colossus — models that can be [emphasis] only available in Cursor. [short pause] Suddenly the VS Code fork problem looks different. Because the moat isn't the editor, the moat is the model. And nobody can copy the model without a million GPUs. Tim Williams: [inhale] So the question becomes — [pause] does Colossus solve the VS Code fork problem, or does it just paper over it? [short pause] Because if the moat is the model, you still have to deliver it through an editor that performs well. And if the editor is still Electron-based and still feels sluggish compared to Zed or a native JetBrains client — [exhale] then the model is being bottlenecked by the delivery mechanism. Paul Mason: [inhale] That's a fair point. [pause] Unless — [short pause] and I'm just thinking out loud here — unless the compute access accelerates Cursor's migration away from VS Code. [inhale] With 200,000 GPUs, you're not just training code models. You could be training models that help you [emphasis] rewrite your own editor. [chuckle] Meta-level stuff. Use the AI to escape the architectural corner you painted yourself into. Tim Williams: [inhale] That's — [pause] that's actually a wild idea. [chuckle] Using the AI to rewrite the editor that the AI lives inside of. That's so recursive it almost makes my head hurt. [inhale] But you know what? [short pause] This is what we keep coming back to in this episode. The tools we built for human-speed development are being asked to operate at AI-speed, and [emphasis] everything is breaking. Not dramatically — it's not like these tools are crashing — but they're creaking. And whether it's CI/CD pipelines or code editors or the entire architecture of how we ship software, [pause] we're in a moment where the foundational assumptions don't hold anymore. Paul Mason: [inhale] So the SpaceX deal — [pause] I think it's genuinely 50/50, even knowing it's real. [short pause] They've got the option to acquire Cursor for $60 billion by the end of the year. If they exercise it, it's either the smartest acquisition in developer tools history because Colossus gives them an unassailable advantage — [short pause] or it's the thing that destroys a beloved product by injecting chaos into a team that needs focus. [exhale] No middle ground. Very on-brand, honestly. Tim Williams: [chuckle] The most Elon outcome possible. [inhale] I will say — [short pause] SpaceX hasn't exercised the option yet. It's a $10 billion partnership right now, with the acquisition decision coming later this year. [pause] But if they do pull the trigger, and if Cursor survives the culture shock, and if they can use Colossus to ship a proprietary model that's genuinely better than anything on the market — [exhale] that could reshape the entire AI coding landscape. [short pause] But that's a lot of ifs. And the $10 billion minimum means they're committed either way. Paul Mason: [inhale] Yeah. [pause] And I think what this deal actually tells us is something real about where the industry is. [short pause] Cursor was vulnerable. VS Code is slowing down. They needed compute they couldn't afford. And the incumbents are scrambling. [inhale] The fact that SpaceX — a rocket company that merged with an AI lab — is the one writing the check? [chuckle] That's not random. That's the market saying, [low voice] the companies that control the compute are going to control the tools. [exhale] And I think we're gonna see more of this. Someone's always gonna make a move. Tim Williams: [inhale] Alright. [pause] That's a good place to land this episode. [short pause] We went from CI/CD pipelines to SpaceX optioning Cursor for $60 billion, and somehow it all connects. [chuckle] The moral of the story might be — [pause] [emphasis] the tools that got us here won't get us there. And figuring out what replaces them is the most interesting problem in software right now. [exhale] Here's looking at you.