From Emacs to Cursor, the end of your IDEs is near | Maleus<br>EN<br>Book a demo

Back to blog<br>EngineeringMay 26, 2026· 7 min read<br>From Emacs to Cursor, the end of your IDEs is near<br>For fifty years, the code editor kept evolving without ever leaving the developer's machine. With agents, that era is ending.<br>Adrien MaretCTO

On this pageWhy we used to code locally<br>But we don't type the code anymore<br>What staying local actually costs<br>A machine that saturates the moment you parallelize<br>Secrets lying around everywhere<br>The supply chain attack surface<br>What comes next<br>Cloud environments that orchestrate agents<br>What we're building at Maleus<br>Conclusion<br>code]:text-[0.85em] [&_:not(pre)>code]:bg-muted [&_:not(pre)>code]:text-foreground [&_:not(pre)>code]:px-[0.4em] [&_:not(pre)>code]:py-[0.15em] [&_:not(pre)>code]:rounded [&_:not(pre)>code]:font-mono [&_:not(pre)>code]:font-normal [&_pre]:bg-muted [&_pre]:border [&_pre]:border-border [&_pre]:rounded-lg [&_pre]:p-4 [&_pre]:overflow-x-auto [&_pre]:mb-6 [&_pre]:text-sm [&_pre]:leading-relaxed [&_pre]:[direction:ltr] [&_pre]:text-left [&_pre_code]:text-foreground [&_pre_code]:font-mono [&_pre_code]:bg-transparent [&_pre_code]:p-0 [&_.hljs-comment]:text-muted-foreground/70 [&_.hljs-comment]:italic [&_.hljs-keyword]:text-primary [&_.hljs-attr]:text-primary [&_.hljs-section]:text-primary [&_.hljs-built_in]:text-primary [&_.hljs-meta]:text-primary [&_.hljs-bullet]:text-primary [&_.hljs-name]:text-primary [&_.hljs-string]:text-foreground/75 [&_.hljs-number]:text-foreground/75 [&_.hljs-literal]:text-foreground/75 [&_hr]:my-10 [&_hr]:border-border [&_blockquote]:my-7 [&_blockquote]:border-l-2 [&_blockquote]:border-primary [&_blockquote]:pl-5 [&_blockquote]:text-xl [&_blockquote]:font-medium [&_blockquote]:text-foreground/95 [&_table]:w-full [&_table]:text-sm [&_table]:mb-6 [&_table]:border [&_table]:border-border [&_th]:text-left [&_th]:font-semibold [&_th]:p-3 [&_th]:border-b [&_th]:border-border [&_th]:bg-muted [&_td]:p-3 [&_td]:border-b [&_td]:border-border [&_td]:text-foreground/80 [&_img]:rounded-lg [&_img]:border [&_img]:border-border [&_img]:my-6 ">Emacs in 1976, then Vim, Sublime Text, Atom, VSCode, and today Cursor: for fifty years , the code editor kept evolving, yet it always stayed on the developer's machine.

And it stayed there for one real reason : the latency between the keyboard and the screen forced every keystroke to give an immediate visual response.

With agents, we're no longer the ones typing the code. We write prompts, launch agents and review what they produce.

In other words, the keyboard is now only used to write instructions.

So the local IDE has no structural reason to exist anymore , and it ships in with a pile of problems we shouldn't accept in 2026: a machine that saturates the moment you parallelize, secrets lying around everywhere, an exploding supply chain attack surface.

In this article, I lay out why I think we're going to stop coding locally and what the dev environment that takes over should look like.

Why we used to code locally

The local IDE exists because we need zero latency between keystroke and visual feedback .

When every character you type has to trigger autocomplete, the linter and the type-checker and then repaint the screen without you noticing, a remote editor at 80ms is simply unusable and the brain feels it immediately.

That's the only serious technical reason to code on your own machine, because the rest of the stack moved to the cloud a long time ago: builds, deployments, execution, CI, storage.

The editor stayed glued to the dev's machine solely because of this keystroke-latency issue.

But we don't type the code anymore

These days, my workflow when I code looks like this: I write a prompt, I launch an agent, I let it run while I do something else, I review the diff it produces and either approve it or redirect it for another iteration.

The keyboard is no longer used to write code, it's used to write instructions.

And writing instructions is prose that has no need for sub-frame latency. The only historical justification for the local IDE just collapsed.

And if these agents manage to produce code you can actually ship, it's because we've learned to feed them the right context at the right moment.

Without that layering, they drift in every direction and the whole workflow falls apart.

I already wrote about this in 2023 in The new era of programming: the developer would become a conductor while LLMs handled the implementation details.

We're there, and a conductor doesn't need their podium sitting on their personal MacBook.

What staying local actually costs

Once the "latency" justification falls, you can honestly look at the balance sheet of what you keep by staying local, and it's not good.

A machine that saturates the moment you parallelize

An agent that codes is a build running in the background, tests executing, a dev server restarting and a pile of files being watched continuously.

So if you run three of them...