I have been living in the terminal more than ever lately.

Not because I suddenly hate GUIs. The terminal just started feeling like the place where the interesting work happens again. Between Claude Code, Cursor’s agent mode, Windsurf, and whatever Aider fork is hot this week, the old “open IDE, click around, type some code” loop feels… slow.

But I am not ready to declare the IDE dead. Not yet.

the shift is real, but it is not just about speed

The argument for agentic terminals is straightforward.

You describe what you want. The agent plans, edits files, runs tests, fixes issues, and hands you a diff or a PR. You stay in one window, keep your hands on the keyboard, and avoid the context switch of clicking through project explorers and sidebar panels.

For a lot of the work I do (platform code, infrastructure tweaks, small services, config changes), this flow is genuinely faster once you have decent guardrails.

The problem is what happens after the agent is done.

IDEs were never just editors

People treat IDEs like fancy text editors with extra buttons. That underestimates what they actually provide.

A good IDE gives you:

• reliable, fast navigation across a large codebase
• accurate refactoring that understands the language semantics
• integrated debugging with breakpoints and variable inspection
• test runners that know how to run just the right subset
• linting and type checking that updates as you type
• version control integration that does not require remembering ten different CLI flags

An agent in the terminal can do many of these things now. But “can do” and “does reliably without supervision” are still different.

I have watched agents propose refactors that looked clean in the diff and then broke three downstream services because the agent never ran the full test suite in the right environment. The IDE would have at least shown me the red squiggles before I even considered merging.

the new default for senior engineers is hybrid

The engineers I respect most right now are not pure terminal maximalists or pure IDE loyalists. They are hybrid.

They keep an IDE open for:

• deep exploration of unfamiliar code
• complex debugging sessions
• anything that requires understanding call graphs or type relationships across multiple files

They drop into the agentic terminal for:

• greenfield work inside well-understood boundaries
• repetitive refactors with clear acceptance criteria
• anything that can be described as “make this change and verify it passes these checks”

The skill is knowing which mode the current task actually needs.

Most people default to whichever tool they opened first that morning. The people shipping faster are the ones who switch deliberately.

the governance problem nobody wants to talk about

Here is the part that actually keeps me up.

When the agent lives in the terminal, it is easier to give it broad permissions. It already has your shell environment. It can already run commands. Adding “let it edit files and run git” feels like a small step.

When the same capability lives inside an IDE plugin, the blast radius is usually more contained because the plugin model forces more explicit permission boundaries.

We are about to learn this lesson the hard way.

Enterprise-managed terminal agents are coming (GitHub already started with Copilot CLI plugins). The organizations that treat this as “just another CLI tool” instead of “a new privileged runtime” are going to have a very bad time when an agent decides the fastest way to fix a failing pipeline is to disable a security check it does not understand.

what actually changes for daily work

I am not saying stop using your IDE. I am saying the default starting point for many tasks has shifted.

For a platform engineer in 2026, the practical setup looks something like:

• Terminal agent for the first 60-70% of the work (scaffolding, obvious changes, test updates)
• IDE for the parts where you need to understand why something is behaving strangely
• Both tools sharing the same git workspace so the handoff is cheap

The people who get this right will spend less time in meetings arguing about “AI productivity” and more time actually shipping.

The people who get it wrong will either stay stuck in 2024 workflows or hand the keys to agents that quietly create more work than they save.

I am still figuring out the exact balance for my own setup. But I know the old “just open the IDE and start typing” default is already gone for a lot of the work that used to feel normal.

The terminal is not winning because it is cooler. It is winning because, for certain classes of changes, staying in one context with an agent that can act is simply higher leverage.

Just do not pretend the governance and verification problems disappeared because the interface got simpler. They just moved.