The IDE Isn't Dead. It's Where the Agentic Stack Starts.
Every few months someone writes the “IDEs are dead” post. When Cursor launched, people said it killed the traditional editor. Then, they said agentic CLIs like Claude Code were sure to kill Cursor.
The implicit assumption is that 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? I’ve grown cautious of predicting anything with too much certainty when it comes to AI, but that’s simply not where most developers are right now. Treating it as inevitable doesn’t help anyone ship faster today.
The IDE isn’t dying. In fact, I’d argue it’s the core of the agentic coding experience. The terminal, the browser, the CLI, and cloud agents aren’t replacements for the editor, they’re extensions of the same workflow. The interesting question isn’t which interface wins. It’s how you build something that makes all of them work together without the developer having to think about the gaps between them. And on top of that, it’s how you achieve elegant, intelligent agentic orchestration that ships quality production code.
Those are the actual innovation points in AI-assisted development right now.
There’s still a lot of innovation left in the editor
Many companies are moving away from the IDE, whether they think it’s obsolete, that developers don’t want it anymore, or that there are more urgent opportunities elsewhere in the stack.
We don’t see it that way. The IDE is where the majority of development actually happens, and getting it right is a prerequisite for building anything that deserves to be called an end-to-end platform. Not to mention: 49% of developers don’t use AI for daily work. The best chance of adoption is to meet them where they’re at, and make it seamless to get going.
Developers that have adopted AI want it to be a close collaborator: one that takes guidance well, stays out of files it shouldn’t touch, and isn’t rash when something is ambiguous. Getting that relationship right takes real investment in the IDE layer, not a pivot away from it. That’s why we entirely rebuilt our VS Code extension with orchestration and agent management as the focus.
Parallel execution is where the real leverage is. Kilo’s Agent Manager lets you run multiple agents across separate worktrees 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. Kilo’s native orchestration breaks down a complex task and distributes subtasks across specialized agents (Code, Debug, Plan, Ask) so that work that used to be serial runs in parallel.
These features matter, but in order to truly future-proof your workflow, the platform has to be model-agnostic. Cursor selling to SpaceX did little to ease concerns about vendor lock-in. And with Anthropic reverting to API-based pricing for businesses, there are now two major AI coding players that have made moves toward a closed, controlled ecosystem. Kilo is, and always will be, model-agnostic, because we believe the tools you use should never be held hostage to the business interests of the underlying model provider.
The IDE is the seed of a larger network
Meeting developers where they’re at means accepting that not every developer is always at their IDE, which is why we’re focused on building the most complete, end-to-end platform for agentic engineering.
Some work is better suited to the CLI. Review and architecture discussions happen on a phone or a tablet, away from a desk. Teams reviewing pull requests don’t want to open an extension; they want feedback inline in GitHub when the PR lands. Cloud Agents mean you can run workloads without a local machine at all.
What actually emerges in developer workflows isn’t “one interface wins.” Developers move between interfaces depending on the task. A session that starts in VS Code shouldn’t disappear when you switch to the CLI. A task kicked off from the web dashboard should resume in the editor without losing state.
Kilo Sessions are built around this. Session history, active agents, and context follow you across interfaces. Start something on the web, finish it in the editor, or hand it off to a teammate who picks it up in the CLI.
KiloClaw takes this even further. It’s a 24/7 background agent that works when you aren’t - scheduling its own automations, connecting to external tools, and taking action without needing a prompt for every step. It’s not a coding agent specifically (though it can handle code through the native Kilo CLI). It’s closer to ambient infrastructure: the kind of automation most developers know they want but don’t have bandwidth to set up and maintain.
All of this points to the same conclusion: reducing friction across every surface, at every layer, is the actual product.
Friction is a product discipline
The instinct when building developer tools is to add capabilities. Capabilities matter, but developers who stop using tools usually don’t cite missing features. They cite friction.
The agent that requires too much setup. The billing model you can’t predict. The extension that breaks when the underlying model changes. The platform that knows nothing about your codebase unless you paste it in manually every session. An end-to-end, cohesive platform solves for these friction points when it’s truly model-agnostic and designed to optimize your workflow instead of the interests of a model lab or provider.
Plus, Kilo’s pricing is open by design: pay per token at cost, 500+ models, no markup. When a new model drops, you can use it immediately. If a model isn’t working well for a specific task, you swap it mid-session. Kilo Credits cover everything from the IDE, to the CLI, to KiloClaw, to App Builder, so you’re not managing separate subscriptions across different surfaces.
That’s not a flashy value proposition, but it determines whether developers are still using the tool six months from now, when the latest model drops from a new frontier lab and everyone is evaluating their stack again.
The end-to-end platform is the answer
The future of AI-assisted development isn’t one interface replacing another. It’s the infrastructure that makes every interface better and moves fast enough to keep up with a space that changes week over week.
Over a million developers are already building on Kilo. The IDE is still very much alive. The CLI matters, and so do the web, the background agents, the parallel workstreams. Building the best agentic engineering platform means building the best version of every touchpoint, not picking one surface and hoping the rest of the workflow figures itself out.