The Good Tech Companies - The IDE Isn't Dead!

Episode Date: May 8, 2026

This story was originally published on HackerNoon at: https://hackernoon.com/the-ide-isnt-dead. Why IDEs remain central to AI-assisted software development despite the rise of coding agents, CLIs, and autonomous tooling. Check more stories related to machine-learning at: https://hackernoon.com/c/machine-learning. You can also check exclusive content about #ai-coding-agents, #vs-code, #kilo-code, #cursor-ide, #developer-tooling, #claude-code, #agent-orchestration, #good-company, and more. This story was written by: @kilocode. Learn more about this writer by checking @kilocode's about page, and for more stories, please visit hackernoon.com. Every few months someone declares the IDE dead. The data says otherwise: VS Code usage is at 76% and growing, AI trust among developers has dropped to 33%, and the review bottleneck created by AI-generated code is getting worse, not better. The IDE is the only interface with the density of information and control needed to verify AI output at scale. Meanwhile, vendor lock-in is accelerating (SpaceX/Cursor, Anthropic's third-party blocks), making open, model-agnostic tooling a strategic necessity. The IDE isn't obsolete — it's the foundation of the end-to-end agentic engineering platform.

This audio is presented by Hacker Noon, where anyone can learn anything about any technology. The Ide isn't dead, by Kilo. Every few months someone writes the, Ides are dead, post. When cursor launched, people said it killed the traditional editor. Then, agentic clis like Claude code were supposed to kill cursor. Now, SpaceX Ice potentially acquiring cursor for $60 billion, and people are concerned about what this means for their favorite developer tools. The implicit assumption is always the same. We're one paradigm shift away from the editor becoming obsolete. Eventually, we'll just think of an idea and deployable software will come out the other end of our implantable chips, right? To be fair, I've grown cautious of

predicting anything with too much certainty when it comes to AI. But I'd transcension is simply not where most developers are right now. Treating it as inevitable doesn't help anyone ship faster today. The I'd isn't dying. In fact, I'd argue it's the center of gravity in the agentic coding experience, and it should be. The terminal, the browser, the CLI, and cloud agents aren't replacements for the editor. They're extensions of the same workflow that work best when they orbit around a strong ID layer. The interesting question isn't which interface wins. It's why the ID remains the right foundation for everything else, and why abandoning it now is a mistake. The ID isn't dead because developers haven't left it.

Let's start with what's actually happening, not what the hot takes predict. VS code alone commands 75, 9% daily usage among developers according to the 2025 Stack Overflow Developer Survey, up from 73. 6% in 2024. The gap between VS code and every other tool keeps getting wider, not smaller. Even subscription-based, AI native editors like Cursor, 17. 9% usage haven't dented the dominance of VS code and visual students. which held their top two spots for the fourth consecutive year.

Intell EJ idea usage among Java developers jump from 71% to 84% in the same period. These aren't tools clinging to relevance. They're growing. The ides are dead. Argument usually leans on adoption curves for other agentic alternatives. But the data doesn't actually support a replacement narrative. Claudecode reached 10% adoption in the Stack Overflow survey. That's real traction, but it's 10% compared to view.

Vs codes 76%. Even cursor, a fast-growing AI native editor, sits at 17.9%. What the data shows is that AI native tools are growing alongside traditional IDS, not instead of them. Most developers who use cursor or Claude code also use VS code. The editor isn't being displaced. It being augmented, trust is still low outside of the Ide. Here's the part that the Ides are dead. Crowd tends to ignore. developers don't completely trust AI output yet. While 84% of developers say they use or plan to use AI tools, positive sentiment toward those tools has actually declined, from over 70% in 2023 and 2024 to just 60% in 2025. Trust in AI accuracy sits at just 33%. Only 2.6% of experienced devs say they highly trust, AI output, and 20% actively distrusted. The biggest frustration

cited by 66% of developers is dealing with AI output that's almost right but not quite. 45% say debugging AI generated code talk us more time than they expected. That trust gap is not a temporary adoption curve issue. It's a structural feature of how current models work and it has direct implications for tooling. When you don't fully trust the output, you need visibility into what changed, you need the ability to review diffs line by line, you need selective revert, and you need context about why a change was made. All of that is IED territory.

A terminal can show you a diff, and IED lets you understand it, navigate it, and Ike on it in context. A sonar survey of over 1,100 developers found that developers estimate 42% of the code they commit is now AI-assisted, but they spend more time reviewing that code than writing it. That's the actual bottleneck in AI-assisted development right now, not generation, but verification. and verification is an inherently visual, spatial, context-dependent activity.

It happens in an editor, not always a chat window. The Stack Overflow Survey reinforced this from another angle. When developers were asked what makes them endorse a new technology, reputation for quality, and, robust and complete API, ranked far higher than AI integration. AI integration came in second to last. Developers aren't looking for more AI. They're looking for AI that actually works well enough to trust. That distinction matters because it means the winning tools won't always be the ones that go furthest with AI autonomy.

They'll be the ones that get the human AI collaboration layer right. And that layer lives in the Ide. The Ide is important because the review surface is growing. As AI generated code volume increases, the review surface increases with it. Sonar's research found that despite the promise of AI reducing developer toil, the overall proportion of time developers spend on low-value work hasn't meaningfully decreased. Developers still spend roughly 23 to 25% of their work weak on repetitive tasks regardless of how much they use AI. The nature of the toil is shifted, less boilerplate writing,

more validation and review, but the total time hasn't budged. This is predictable if you think about it. AI generates code faster, which means more code to review. AI makes mistakes that look plausible, which means review stake longer per change. AI operates across files simultaneously, which means the diff surface area is larger. Every one of those dynamics makes the IID more important, not less. The 77% of developers who say, vibe coding, is not part of their professional workflow or telling you something about production software. You can prototype in a chat window. You can explore ideas in a terminal, but when code needs to bear reviewed, tested, committed, and shipped, it passes through the editor. That's not inertia or nostalgia. It's the fact that no other interface

provides the same density of information and control for that stage of the workflow. The Ide is the anchor of the end-to-end platform. Once you accept that the I'd isn't going away, the question becomes, what should the I'd become? My argument is that the I'd should be the central interface in a broader, end-to-end agentic engineering platform. Not the only interface, but a central one. The place where context is richest, where review happens, where the developer has the most control. Other surfaces, the CLI, the web, cloud agents, background automation, extend the platform's reach and meet developers where they're at in different parts of their workflow. This is the approach we've taken with Kilo. RVS code extension was entirely rebuilt with orchestration and agent management

as the focus, because that's where the highest leverage problems are. Kilo's agent manager lets you run multiple agents across separate work trees simultaneously, organized into groups, with full visibility into what each one is doing. You can review inline diffs, selectively revert individual file changes, and track PR status without leaving the editor. Native orchestration breaks down complex tasks and distributes subtasks across specialized agents, code, debug, plan, ask, so that serial work runs in parallel. That's the kind of feature set that only makes sense inside an IDE, it depends on the spatial, navigable, file-aware environment that an editor provides. But the ID alone isn't enough, and pretending otherwise is just as wrong as saying it's dead. Some work is better

suited to the CLI. Review and architecture discussions happen in Slack. Teams reviewing pull requests don't want to open an extension. They want feedback inline in GitHub when the PR lands. Cloud Agents Me and You Can Run Workloads remotely. What actually emerges in developer workflows isn't, One interface wins. The JetBrains developer ecosystem survey found that 85% of developers regularly use AI tools for coding and development, and 62% rely on at least one AI coding assistant, agent, or code editor. They move between interfaces depending on the task, and any tool that forces them to commit to a single surface is going TOLOS. That's why Kilo Sessions retain context across all interfaces, and why Kilo Klaw exists as a 24-7 background agent that can schedule its

own automations, connect to external tools, and take action without needing a prompt for every step. The IDE is the center, but the platform extends everywhere the developer goes. The alternative to the I'd is vendor lock-in. There's a more cynical reason the IED matters right now, and it's worth being direct about. The companies building the most prominent AI coding tools are increasingly building closed ecosystems. On April 21st, 26, SpaceX announced a deal giving at the right to acquire Anisphere, Cursor's parent company, for $60 billion. The deal pairs Cursorses I'd with Zay's Colossus training infrastructure, and the stated goal is to build Cursor's own frontier model. Enterprise customers who adopted Cursor are now reassessing. On April 4th,

Anthropic blocked Clawed Pro and max subscribers from using their flat rate plans with third-party agent frameworks, starting with open claw, while explicitly exempting their own Codd code. enterprise billing has shifted to mandatory consumption commitments with legacy volume discounts being removed. The Pragmatic Engineers 2026 survey captured the developer sentiment around this directly. Experienced engineering leaders described the pattern as identical to what cloud providers did a decade ago, subsidizing early and then raising prices once customers were locked in. 94% of IT organizations are now concerned about vendor lock in according to a 2026 parallel survey,

with nearly half saying they are very concerned. Among AI coding tool users specifically, around 15% mentioned cost concerns unprompted, and the cost trajectory is widely considered unsustainable for heavy users. This is where an open model agnostic guide layer becomes a strategic asset, not just a nice to have. When your editor doesn't care which model you use, you can switch models the day a better one drops without reworking your entire workflow. When your tooling charges per token at provider cost with no markup across 500 plus models, you're not subsidizing someone else's vertical integration play. Even Jed Brains now explicitly describes multi-vender support as something they're committed to,

calling it not a nice to have. Kilo's pricing is open by design for exactly this reason. Kilo credits cover everything from the I'd to the CLI to Kilo Kla to Abdelder, and the economics don't change based on which lab had a good quarter or which acquisition just closed. The Ide is the foundation. Build up from there, the IID isn't dead, it isn't dying, and the companies that treat it as a solved problem, or worse, an obsolete one, are neglecting arguably the most important surface in the developer workflow. Kilo officially just reached 3 million downloads. We're investing in the IDE because it's where the agentic stack starts, and we're building

the end-to-end platform around it because that's where the agentic stack needs to go. The editor is the center, and everything else extends from there. Thank you for listening to this Hackernoon story, read by artificial intelligence. Visit hackernoon.com to read, write, learn and publish.