"The IDE is Dead, Long Live the IDE"

JetBrains, My Beloved

The amount of change in the world of software development and dev tooling has been a huge wave that's hit the industry in force. In just the past few months, we've started seeing the largest shift in how developers work and code.

My generation has only known a good old-fashioned IDE, like many, I started with open-source IDEs like Eclipse and NetBeans in Java, and then made the move to IntelliJ once I had the great privilege of working at a company that was willing to pay for a license. Naturally, as I worked more and more with web-based languages & frameworks like React and Angular, I started playing around with leaner text editing tools like Atom (rest in peace) and VS Code. Once I started writing code in Go, right back to JetBrains again with GoLand.

Ultimately, after a decade of coding with these tools, JetBrains products always came out on top. The relatively hassle-free out-of-the-box experience, the polish and the time saved from dealing with project setups and configuration issues that plagued other IDEs and editors was a big plus. Big enough for one to look past its INSATIABLE hunger for memory. Many co-workers and friends shared the same preferences.

In the last four months, I haven't opened a JetBrains product (or any traditional IDE for that matter) for more than a few minutes in a single day, in fact, I actively avoid it! Why? You guessed it, I went back to the only IDE that ever truly captured my heart: Ready to Program .

Ready to Program by Holt Software - we didn't know how good we had it until it was gone

No, obviously not, AI, agents, terminals, claude code, buzzwords!

Without actively writing the code yourself, there's little need for all the tooling, functionality, and extra bells and whistles of a traditional IDE. With agent driven workflows, you really only need two things:

A way to instruct the agent(s) and keep up with progress

A way to review the output

You don't have to use an IDE for either! Most if not all the tooling for running tests, accessing databases, linting, etc. can be handled by the agents via the CLI

With more and more developers coding through the terminal, we've seen a whole plethora of terminal apps, emulators, and agent workflow organization tools gain popularity as well as a few new contenders hit the market. Each racing to be the next go-to tool for developers. While traditional code editors and IDEs are almost certainly on the way out, the world of IDEs is evolving and the tooling is morphing into something else

Having been on the hunt myself for something that could help manage the dozen or so Claude sessions that are left open on any given day at work, I've shuffled through a number of setups and tools that each provide their own unique workflow improvements. Only one has really stood out so far: Maestri .

Maestri · An orchestration canvas for AI agents

Orchestrate multiple AI agents, terminals, sketches and notes on one infinite canvas. Built for macOS.

I initially started playing around with tmux, gpu-accelerated terminal emulators like Ghostty and kitty , and terminals with extra tooling for cli-based workflows (i.e cmux , superset , and warp ). Throughout all of this, the focus was mostly on finding a terminal that could address some of the shortcomings/inconveniences of a purely CLI-based approach to development. More specifically, I was struggling to keep my work organized, juggling five or more Claude Code conversations at once, some in terminal tabs and others in split panes with related chats, while also trying to switch contexts and multitask effectively.

Cue in Maestri

Maestri is a total reimagination of the terminal-based agent experience. It's built specifically to facilitate multitasking and coordinating several agents at the same time. While a lot of other terminal apps aim to do the same thing, Maestri stands apart from the crowd.

One of the reasons it stands out is that it's heavily opinionated, and honestly barely even a terminal app. When you first open it, you might be forgiven for thinking you opened a canvas-based app like Miro or Excalidraw . You start with a blank canvas and work your way up from there. You can create terminals, sticky notes, add images, titles, and even open up an in-app browser to help you organize your thoughts and your work. In fact, there's nothing really forcing you to use the terminal here! You can go about your day and use it to take notes or make a mind map.

The real magic starts when you set up a terminal window, from here, you can set the name of the terminal, the command that runs when the terminal is started, the directory it should run in, and even custom roles/instructions for any agents running in that particular instance.

Aside: this has a very neat side-effect! If you've ever had multiple Claude sessions open at a time and have had to restart your terminal or computer for whatever reason, re-opening those sessions and getting your terminal back to the state it was in is always a hassle. By being able to set the default command of a terminal window, you can set each instance to automatically resume that chat thread on the next reload, picking right back up from where you left off!

The custom roles are configurable and re-usable. Take this very standard example of an agent orchestrator: a coordinator, an implementer, and a supervisor. The coordinator is responsible for planning and instructing other agents, the implementer for actually making the intended changes, and the supervisor for constantly monitoring the changes the implementer makes for CI failures, PR feedback, etc.

Defining these roles is simple enough, but actually getting the harness set up for these agents to work in tandem is a different story. Most Claude Code users would default to creating a team of agents all handled in one terminal session. This has a few downsides, namely:

A subagent cannot spawn another subagent

Navigating and directing the subagent must all be done via one main chat thread

Communication between agents is unidirectional, the parent agent assigns the tasks, the subagent completes them

Claude agents can only communicate to other Claude agents

Maestri makes this simple with agent connections . You can connect two terminal windows that you've created with each other, and Maestri will automatically set up skills that allow each respective agent to communicate with any other agents its connected to using the CLI.

This feature alone makes it incredibly easy to set up multi-agent workflows and optimize for quality and cost by choosing which model and which agents should run each task. You can imagine a scenario where you leave all the technical planning and complex tasks to a high-cost Opus-level “Coordinator” agent, and have it delegate the actual implementation work to a cheaper or even self-hosted open-source model, while still allowing each agent to run its own subagents. It’s surprising just how well this feature works!

To take it a step further, agent connections aren't even limited to agents! You can choose to connect an agent to the in-app browser to allow it to test the work it does or browse the web without opening a separate instance of Chrome in a new window. You can also choose to connect the agent to notes on your canvas, and it will correctly read and absorb the content of the notes into the chat context!

There are a few other organizational and workflow quality of life features like workspaces and floors (worktrees), each bundled with some very satisfying animations and UX, but the one thing that stands out is the included Ombro agent. When you create a terminal window on the canvas, you have the option of enabling monitoring to detect when an agent has finished its task. The app then gives you a small floating window that acts as a feed with updates on the progress of all of your agents.

It will even propagate questions the agents have for you, and give you a quick and easy way to respond. This seems relatively simple at the surface level, but is a game changer for multi-tasking. At work especially, attending meetings has never felt more productive, this 'at-a-glance' view lets you easily unblock your agents without having to fully switch out of your meeting app or commit to a full mental context switch.

The neat thing about this as well is that it runs completely on-device using Apple's Foundation Models and burns no server-side tokens, which brings us to perhaps the craziest thing about this all; the pricing. Maestri and pretty much all of its features are completely free to use, there is no paid subscription (for now). The only form of monetization is a one-time fee of $18 to unlock the use of multiple workspaces, that's it. In terms of closed source development tools, this is the holy grail of pricing structures. It may not be like this in the future, but in terms of the quality and thought put into the experience, that one-time fee is well worth the price.

Should you use it?

Absolutely, if you're working on MacOS - which unfortunately is the only platform supported - you should absolutely try this out. It isn't perfect by any means; it can't replace your actual terminal, the keyboard shortcuts leave a lot to be desired, and for many simple tasks having to work through a UI to set up a canvas seems a bit tedious and overkill. That being said, in a time where new terminal apps and clones are popping up left and right, Maestri is a refreshing take on the development workflow, and maybe the most indicative of the direction software engineering is heading to.

"computer, G-major"

Forward Deployed Engineers

As a final footnote, you may have heard this term before. It's often used to reference engineers that work very closely with customers. As agents begin to automate more and more of the tedious technical aspects of the software development lifecycle, there will be a greater demand for engineers that have some level of product management skills. Engineers that can independently identify user needs, ideate, prototype, and implement solutions will likely perform better in a world where raw coding ability is not as valuable as it once was.

This is the bet that Maestri and other similar apps are taking. The tooling of old is built strictly for a hyper-technical audience. IDEs like IntelliJ do this very well and aren't going anywhere just yet, but they will need to drastically transform to meet the needs of modern day software development. The important thing to recognize at this stage is that apps like Maestri, as abstract and maybe designer-pilled as they are, are indeed IDEs. We'll continue seeing similar products made until the industry settles into a new norm, some of them might be absurd or jarring, and others might just hit the mark! It's important to be a bit flexible and open to trying each of these tools out to see where they might work in your workflow and where they might fall short.