Here’s the thing about developers: we love new toys. A new framework, a slick new terminal, or a code editor that promises to revolutionize our workflow—we’re drawn to innovation like moths to a flame. For the last couple of years, two names have been buzzing louder than most in the editor space: Cursor & Zed.
Cursor stormed onto the scene as the AI-native wunderkind, a fork of VS Code that put artificial intelligence at the very heart of the coding experience. Zed, from the brilliant minds behind Atom, promised a phoenix-from-the-ashes story: a blazing-fast, minimalist editor built from the ground up in Rust, free from the shackles of Electron.
The hype was real. For a while, it felt like everyone was either trying them, loving them, or proclaiming them the definitive "VS Code killer." But now, the dust is starting to settle, & a different narrative is emerging. A quiet, but growing, number of developers are closing their Zed tabs for the last time & uninstalling Cursor.
They’re not necessarily chasing the next new thing. Instead, they’re retreating to familiar ground, often back to the very tool they were trying to escape: Visual Studio Code.
Why? It’s not about features, themes, or even keybindings. It’s about something far more fundamental: the search for a stable, predictable, & trustworthy coding environment. Turns out, when your livelihood depends on a tool, "boring" & "reliable" can be the most exciting features of all. Let's dig into why some devs are breaking up with the new kids on the block.
The initial appeal of Cursor was undeniable. It looked & felt just like VS Code, which meant virtually no learning curve. All your favorite extensions & settings could be ported over instantly. But it came with a superpower: deeply integrated, codebase-aware AI. It wasn't just another ChatGPT window bolted on the side; it was designed to read, understand, & edit your code directly. For a while, it was magic.
But the honeymoon phase started to wear off, & the cracks began to show.
The first & most common complaint? Performance. While the AI features were powerful, they could bring the editor to its knees. Developers reported that working with large files—a daily reality for most professional coders—caused Cursor to lag & stutter where VS Code would remain buttery smooth. The very AI conversations that were supposed to speed up workflows became a source of sluggishness, with the IDE getting progressively slower & even crashing as chat histories grew.
Then came the reliability issues with the AI itself. The magic started to feel more like a messy illusion. Users on Reddit & other forums began sharing stories of the AI failing on edits for no apparent reason, attempting a change multiple times before giving up. It would sometimes misinterpret requests or fail to recognize pasted code, turning a quick refactor into a frustrating exercise in prompt engineering. For many, this unreliability made the tool unusable for serious work. As one user put it, once it starts failing, it's best to "keep a close eye on everything it does because occasionally claude can get quite destructive."
But the biggest blow to Cursor wasn't about performance or buggy features. It was about trust. In the summer of 2025, cybersecurity researchers disclosed multiple high-severity security vulnerabilities. Flaws like "MCPoison" (CVE-2025-54136) & "CurXecute" (CVE-2025-54135) could potentially allow for remote code execution. Essentially, an attacker could trick the editor into running malicious code by swapping out a configuration file after a user had already approved it.
To their credit, the Cursor team patched these issues quickly. But for developers, the trust model was shaken. Your code editor is your inner sanctum. It has access to your source code, your keys, your entire digital life. The revelation that it could be turned against you so easily was a jarring wake-up call.
The final nail in the coffin for many was that VS Code simply caught up. While Cursor was wrestling with these issues, GitHub Copilot was evolving at a breakneck pace. Microsoft integrated more powerful models, improved its chat capabilities, & expanded its feature set. The unique selling points of Cursor—like the ability to use various LLMs—were no longer unique. Developers realized they could get a very similar, and often more stable, AI experience within the proven, reliable ecosystem of VS Code, without the performance overhead or security concerns.
The Paradox of Speed: Why Zed Stumbled
If Cursor was the AI-first revolutionary, Zed was the purist's dream. Built in Rust by some of the same people who created Atom, its entire reason for being was SPEED. It promised a native, lightweight, & "lightning-fast" experience that would make Electron-based editors like VS Code feel like they were stuck in molasses. And at first, it delivered. The UI was clean, it opened instantly, & basic text editing felt incredibly responsive.
But as developers tried to integrate Zed into their daily, complex workflows, a frustrating paradox emerged: the editor built for speed was, for many, incredibly slow.
On platforms like Hacker News & Reddit, threads began popping up with titles like "Zed (Editor) Has Suddenly Become Terrible, IMHO." Users with powerful machines, including modern MacBooks, reported that Zed would often consume so much CPU that their fans would spin up to full blast. The editor would freeze, features would stop working, & bugs in core functionality like search would force a complete restart.
What was going on? A common theory is that the intense focus on shipping new AI features came at the expense of the core editor's stability. While Zed was rolling out agentic editing & other AI-powered tools, fundamental components like language server integrations seemed to be breaking. The Python support, in particular, was singled out as being consistently buggy. A developer on Hacker News noted, "I am definitely worried they're going to focus on AI slop like everyone else & ignore the core experience."
This highlights a fundamental disconnect between what makes a good demo & what makes a good daily driver. Speed & minimalism are fantastic selling points, but they mean nothing if the editor can't reliably perform the basic tasks of a modern development environment. VS Code, for all its supposed bloat, has a massive, mature ecosystem of extensions that handle things like linting, debugging, & language-specific tooling with incredible stability. Zed, by contrast, with its nearly 3,000 open issues on GitHub, felt to many like it was still in a public beta phase.
This isn't to say Zed is a bad editor. It's an ambitious project with a ton of potential. But for developers who need to ship code today, "potential" doesn't fix a broken linter or a frozen UI. The minimalist approach that was so appealing at first started to feel less like a feature & more like a limitation.
Finding Stable Ground: What Do Developers Actually Want?
This exodus from the bleeding edge back to the tried-&-true reveals a simple truth about professional tools. Novelty is exciting, but stability pays the bills. So what makes for a stable coding environment? It boils down to a few key principles:
- Rock-Solid Performance: First & foremost, an editor must be fast & reliable under real-world conditions. This means handling large projects, multiple open files, & background processes without choking. It should feel responsive, not just on a clean install, but after months of use.
- Unwavering Reliability: A developer's editor cannot crash. It cannot freeze. It cannot lose unsaved work. It must be a dependable tool that "just works" every single day. Trust is paramount.
- Powerful Core Features: Beyond just typing text, a modern editor needs intelligent code completion, accurate syntax highlighting, integrated debugging tools that work flawlessly, & seamless version control integration. These aren't bells & whistles; they are the foundation of a productive workflow.
- Limitless Extensibility: No single editor can be everything to everyone. A truly great editor embraces this through a rich, mature extension ecosystem. The ability to customize your environment to your exact needs—for a specific language, framework, or workflow—is what transforms a good editor into an indispensable one. This is VS Code's undisputed superpower.
- A Healthy, Active Community: A large user base means more people finding & fixing bugs, more tutorials, more extensions, & a higher likelihood that the tool will be maintained for years to come.
When viewed through this lens, the appeal of VS Code becomes crystal clear. It may not be the fastest-booting or the most minimalist, but it is arguably the most stable, extensible, & reliable platform for the vast majority of developers.
The Business of Stability: A Lesson for Everyone
This developer-driven quest for stability isn't just an insular tech debate. It mirrors a universal need that applies to almost any business: the need for reliable, intelligent, & trustworthy tools, especially when it comes to interacting with customers.
Think about it. A developer gets frustrated when their code editor's AI gives a nonsensical answer or crashes. In the same way, a customer gets frustrated when a company's support chatbot misunderstands their question, provides irrelevant information, or hits a dead end. In both cases, trust is eroded & the user is left looking for a more reliable alternative.
This is precisely the problem space where tools like Arsturn come in. Just as developers need a stable environment to build software, businesses need a stable platform to build customer relationships. Many companies are turning to AI to automate their customer service, but as we've seen with Cursor & Zed, just "having AI" isn't enough. It has to be reliable, intelligent, & tailored to your specific context.
This is where Arsturn helps businesses build no-code AI chatbots trained on their own data. Instead of a generic, one-size-fits-all model, a business can create a custom AI assistant that understands its products, its documentation, & its customers' unique problems. This allows them to provide instant, accurate customer support 24/7, answer questions with precision, & engage with website visitors in a meaningful way. When a customer has a problem, they get a helpful answer immediately, not a frustrating dead end. That's how you build trust & loyalty.
Furthermore, when it comes to proactive engagement & growth, a stable AI platform is key. Just as developers use their tools to build new things, businesses can use AI to build their customer base. Arsturn helps businesses create custom AI chatbots that provide instant customer support, answer questions, & engage with website visitors 24/7, turning passive website traffic into active leads & boosting conversions through personalized, helpful conversations.
The lesson is the same whether you're writing code or running a company: stability & trust are not boring features. They are the bedrock of any successful long-term strategy.
The Journey Back Home
The stories of Cursor & Zed are far from over. They are both incredibly innovative projects that are pushing the boundaries of what a code editor can be. For some developers, their features & philosophies will be a perfect fit.
But for a significant portion of the community, the experiment has run its course. The chase for the "next big thing" has, ironically, led them to a deeper appreciation for the "current big thing." They’ve learned that while the allure of a 10x productivity boost from a revolutionary tool is strong, the slow, silent drain of a thousand tiny papercuts from an unstable one is a killer.
They are returning to VS Code not in defeat, but with a newfound wisdom: that a stable, reliable, & extensible tool that you can trust is the most powerful productivity enhancer of all.
Hope this was helpful & gave you some food for thought. Let me know what you think. Have you tried these editors? What’s been your experience?