Why the future of software engineering is beyond the IDE

The IDE feels like hallowed ground for many software engineers. Those of us who have been doing this for a while now have spent countless hours typing code into an editor – enough hours, in fact, that we have a favorite, a bespoke set up, an environment we’ve spent years learning and making our own. I’ve personally been using vim for 20 years.

So it’s no wonder that when agents entered the picture not so long ago, the conversation turned to, “How do we use agents in the IDE?” Because of course that’s where agents would work. That’s where we work. That’s where work gets done. So what do we do, do we fork or integrate? The answer is neither. And I’m not here to say that the editor is dead. But software doesn't only exist in the IDE.

When you’re starting new agents from places like Linear to automatically triage bug reports, or getting a PR automatically from a production alert, you’re going to be focused on reviewing, shaping, and architecting code, not writing every line of it. Sure, you’ll still use an editor to tweak code, but with agentic engineering, you’ll spend more time working as the lead of a team of agents working across your stack, so you can get in the flow faster and ship more.

It’s time to start thinking about how AI expands into work surfaces beyond the IDE.

New work surfaces for a new reality

We’re seeing agentic engineers get things done in hours that used to take software engineers days or even weeks: fixing bugs, generating documentation, restructuring code, and the list goes on. Imagine launching an agent directly from Linear to tackle a CI failure ticket from your PR. Then launching another to review your PR faster than your teammate can even get the notification. This isn’t about agents replacing engineers or one-shotting code, it’s about agents doing the tasks that pull you out of your flow.

In a near future where you’re able to run multiple agents at the same time across your entire stack triggered by nearly any event, the job becomes less about inputting lines of text and more about acting as an architecture expert, a connector of the dots, a long-term vision holder.

Agentic engineering effectively gives us the tech team we’ve all been waiting for. Software agents are the future, and they belong in every part of the software development ecosystem. The editor isn’t the place to manage this work, yet our surfaces haven’t caught up yet to where we need to be. The future will require:

• New and improved tools that allow you to review and edit agent-produced code for consistency, quality, system design concerns, and everything else that makes your company’s code uniquely yours
• Transparent and secure cloud environments for agents to work on issues and test code before you review it
• A way for you to monitor the progress of all agents in real time, regardless of where they started

And that’s just the beginning. Right now, we’re thinking in terms of how humans build software, but as agents get better at building software, requirements will continue to change and evolve.

What’s next

The move beyond the IDE is just one of the many changes we’re going to see in software development over the next few years. And we’re excited to be taking the first step in that direction by untethering agents from the editor so they can help you build across your entire stack.

Yesterday, you were limited by your IDE, but tomorrow, the only limit to what you can do is you. In a world where you can drop an agent anywhere software runs, where you have a transparent view of every agent running in parallel, where you can trigger an agent based on nearly any event, the question becomes: besides writing code, what else can the agent do for you? Can it review your CI failure, fix your tests, review your code, help you deploy?

And in this reality, what can’t you ship?