I was looking at my screen earlier today and realized I have seventeen different terminal windows open, and I can only find the one I actually need about twenty percent of the time. It is that classic developer trap where you start with one simple task, and three hours later you are buried in a mountain of open SSH sessions, half-finished git commits, and five different instances of htop just to see which one of your local agents is eating all the RAM. It feels like I am trying to pilot a 747 using only a collection of sticky notes and a flashlight.
Herman Poppleberry here, and I have to say, that is the most relatable thing you have said all week, Corn. We have reached this bizarre point in March of twenty twenty-six where the terminal is simultaneously our most powerful tool and our biggest source of cognitive friction. We are working across more environments than ever—local, cloud, edge, containers—and the mental overhead of just keeping track of where you are is becoming a full-time job.
It is the "productivity paranoia" of the modern era. I feel like I am working harder just to stay organized than I am actually writing code. And it is not just me—I saw that report from earlier this month saying eighty-five percent of managers are feeling that same paranoia about remote work. They want to know what is happening, and we are just struggling to find the right tab.
Today's prompt from Daniel is about this very struggle, specifically the evolving terminal landscape and how we are trying to bridge the gap between the raw speed of the command line and the visual discoverability of a graphical interface. We are moving away from the terminal as just a text box and toward what people are calling the Agentic Development Environment, or ADE.
Before we dive into the new shiny tools, let us frame this for a second. In my head, I have this hierarchy. We have the CLI, which is the pure engine. It is fast, but it is a black box if you do not know the commands. Then you have the GUI, which is the map. It shows you everything, but it is slow and hard to automate. And now we have the TUI, the dashboard. I feel like the TUI—or "TOO-ee" for the uninitiated—is the unsung hero for people like me who want to stay in the flow without having to keep a hundred-page cheat sheet on their desk.
That is a great way to put it. The TUI gives you that visual feedback—windows, menus, progress bars—but it stays within the terminal grid. It is keyboard-driven and, crucially, it is light enough to run over a remote connection without the lag you get with a remote desktop. We are seeing a massive shift from "terminal as a tool" to "terminal as a platform." Look at what Warp has been doing with their ADE shift. They are trying to make the terminal the center of the universe again, but with all the bells and whistles of a modern IDE.
It is funny because for years, the advice was just to learn more keyboard shortcuts. If you are slow, it is because you have not memorized enough of the arcane tmux incantations. But Daniel is pointing toward this middle ground. Why are we still obsessing over the terminal in twenty twenty-six when we have these incredibly sophisticated IDEs?
Because the terminal is the only interface that actually scales with the complexity of what we are building. You cannot put a million-line codebase into a web form, but you can navigate it in a terminal if you have the right tools. And the timing of this discussion is perfect because the last two weeks have seen some of the most significant updates to the terminal stack in years. We have had major releases from Zellij and Ghostty that are fundamentally changing how we think about persistence and navigation.
Let us talk about Zellij first. I have heard the name—rhymes with "knowledge," right?—but I have been a tmux user since the dawn of time. Why should I care about Zellij zero point forty-four point zero, which just dropped on March twenty-third?
Zellij is a Rust-based terminal multiplexer, and this latest update is a massive deal. First off, they finally added native Windows support. For the developers out there who are stuck in a corporate Windows environment, being able to run a high-performance multiplexer without jumping through WSL hoops is a huge win. But the real "wow" feature is the Terminal-to-Terminal Attach over HTTPS.
Explain that to me like I am a sloth who just wants to get his work done. Why does this matter more than just a standard SSH session?
In a traditional setup, if you want to share a terminal session or move from your laptop to your desktop, you are usually relying on a persistent daemon like tmux running on a server. It works, but the setup is clunky and the security is often just "hope nobody steals my SSH key." What Aram Drevekenin and the Zellij team have done is introduce a way to attach to remote sessions via a web server with full HTTPS authentication. This means you can have a persistent workspace sitting on a powerful remote server, and you can attach to it from any terminal emulator on any machine just by hitting a URL. It handles the security and the handoff natively.
So it is basically turning my terminal into a cloud-based operating system that I can just plug into whenever I need it. That feels like a direct response to that "productivity paranoia" we mentioned. If everything is persistent and shareable, I can literally show my manager or a teammate exactly what I am doing in real-time without a laggy screen share.
And they added a new Layout Manager plugin. This lets you record the exact state of your workspace—which panes are open, which directories they are in, what tools are running—and save that as a template. Imagine you are working on a specific microservice architecture. You have six repos, three log tails, and a database monitor. Usually, that takes ten minutes to set up every morning. With Zellij's new layout manager, you just load the template and you are exactly where you left off. It even has "Stacked Resize" now, which lets you perform bulk operations on a stack of panes. If you have a giant monitor and you are managing twenty windows, you can grab a whole group and move them together. It reduces the "fiddling" time.
I need that. I spend half my life just dragging window borders around. But what about the actual terminal emulator itself? I have been hearing a lot about Ghostty lately. Mitchell Hashimoto's project?
Yes, Ghostty one point three point one just came out as a patch for the big one point three point zero release from March ninth. Ghostty has become this absolute juggernaut. It is a GPU-accelerated terminal emulator that is seeing nearly one million downloads per week on macOS alone as of this month. Mitchell Hashimoto, who founded HashiCorp, is the driving force here, and he is obsessed with performance. The big thing in this version is the introduction of "key tables."
Key tables sounds like something I would find in a database, but I am guessing it is about keyboard mapping?
It is a system for chained keybinds that enables modal workflows. Think about how Vim works, where you switch between insert mode and normal mode. Ghostty is bringing that logic to the terminal emulator itself. You can create a "git mode" where your keys do different things. For example, you hit a leader key to enter "git mode," and then "s" shows status, "c" commits, and "p" pushes. But here is the kicker: it does this without needing a persistent background daemon like tmux. It is all handled in the fast path of the terminal itself.
That is the kind of optimization that makes my sloth brain happy. You get the power of a complex multiplexer, but without the overhead of another process running in the background. It is just clean, fast, and responsive. I have noticed that when things are faster, I am less likely to get distracted. If I have to wait even half a second for a window to redraw, that is half a second for me to wonder what is happening on social media or check the news.
The latency matters more than people realize. We are seeing a shift where the terminal is no longer just a place where you type commands; it is becoming an Agentic Development Environment, or ADE. Warp announced their "Oz" platform back in February, and it is a perfect example of this. They are moving from "AI-assisted" where you have a chatbot in a side panel, to "AI-autonomous" where agents can run tasks asynchronously in the cloud.
Wait, so I can tell an agent to go clean up dead code in a repository, and it just does it in the background while I am working on something else?
That is the vision. With Oz, these agents run in a headless environment. They can interact with REPLs, debuggers, and the file system. You can schedule them to run dependency updates at three in the morning or have them perform a security audit on a new branch before you even look at it. It is a massive jump in capability, but it also brings us to that "verification bottleneck" we saw in the twenty twenty-five developer survey.
Right, the numbers were eighty-four percent of developers are using AI, but positive sentiment dropped to sixty percent. That is a ten percent drop from the year before. I think people are starting to realize that while the AI can write the code, verifying that the code is actually good and secure is becoming a full-time job in itself. It is like having a very fast junior developer who occasionally tries to set the building on fire.
It is the "trust but verify" problem. If you have an agent running around in your terminal, moving files and changing code, you need a way to see exactly what it did. This is why these modern TUIs and multiplexers are so important. They provide the observability. If I am using something like Zellij's session sharing, I can actually watch the agent work in a shared pane. I can see the commands it is running in real-time. It is not a black box anymore.
It is also a massive security issue. We saw those reports earlier this month about North Korean operatives trying to infiltrate remote IT roles. If you are a manager and you have eighty-five percent of your team working remotely, you want to know that the person—or the agent—logging into your terminal is actually authorized. These new HTTPS-based attach protocols with robust authentication are not just about convenience; they are about defending the perimeter.
That is a very valid point. The terminal is the keys to the kingdom. If someone has shell access, they have everything. As we move toward these more complex, agent-driven workflows, the security model has to evolve. We cannot just rely on a simple SSH key anymore. We need identity-aware proxies and encrypted session sharing that can be audited. We actually touched on some of the broader security implications of the developer workflow back in episode ten seventy, "The Agentic Secret Gap," which is worth a listen if you want to go deeper on how to secure these agents.
I want to go back to the TUI side of things for a second. Tools like lazygit or yazi. I feel like they are the bridge for people who find the jump from a GUI to a pure CLI too intimidating. It gives you the visual confirmation of what you are doing. You can see the git tree, you can see the file structure, but you are still moving at the speed of light because you are not taking your hands off the keyboard.
Charm dot sh has been the real pioneer there. Their Bubble Tea and Lip Gloss libraries have made it so much easier for developers to build these visually rich TUIs in Go. It is why we have seen this explosion of beautiful terminal tools. And since Python has officially overtaken JavaScript as the most-used language in the latest surveys, we are seeing a lot of these terminal-centric data science workflows being built with similar logic. People are managing massive machine learning clusters entirely through high-performance TUIs.
It is a funny cycle, isn't it? We went from the terminal to the desktop, then to the web, and now we are all flocking back to the terminal because it is the only interface that actually scales with the complexity of what we are building. But there is a risk of bloat, right? I see people complaining about Warp's mandatory login and the telemetry they collect. There is this tension between the "suckless" philosophy of minimal, fast tools and this new "terminal as a platform" approach.
There is definitely a divide. You have the purists who will never leave Alacritty and tmux because they want total control and zero telemetry. And then you have the new generation of developers who are happy to trade a bit of privacy or "bloat" for the massive productivity gains of integrated AI and cloud-synced sessions. I think both can coexist, but the important thing is that the performance is finally catching up. Whether you are using Ghostty or Warp, you are getting low-latency, GPU-accelerated rendering. The "slow terminal" is a thing of the past.
So, if I am a developer listening to this and I am feeling overwhelmed by my seventeen open tabs, what is the first step to cleaning up my terminal life?
First, I would say do an audit of your workflow. Are you spending more time navigating than you are coding? If so, look at a multiplexer like Zellij. The "mode-based" navigation is a game changer because it puts the commands right there at the bottom of the screen. You do not have to memorize a hundred shortcuts on day one. It tells you exactly what keys are available in your current mode. It lowers the barrier to entry significantly.
And maybe try Ghostty if you are on Mac or Linux. The performance alone is worth it, and the "key tables" feature lets you build a workflow that fits your brain, not someone else's idea of how a terminal should work. I think the key is to stop fighting the terminal and start building a workspace that actually supports the way you think.
We are moving toward a world where the GUI might actually disappear for a lot of technical tasks. If your TUI is discoverable enough and your AI agent is capable enough, why would you ever leave the terminal? It is the most efficient interface we have ever invented. And with the security concerns around remote work and the need for persistent, shareable sessions, the terminal is the only place that can actually provide the level of control and transparency that modern engineering requires.
It is a bit of a return to our roots, but with a lot more horsepower under the hood. I am still going to have seventeen tabs open, but maybe with these new tools, I will actually know what is in ten of them. That would be a massive improvement for me.
We should also mention the practical side of this. If you are moving to a more agent-centric workflow, you need to be thinking about your "agentic secret gap." We talked about this in episode ten seventy, but it is worth repeating: when you give an agent the ability to run commands in your terminal, you are giving it access to your environment variables, your SSH keys, and your cloud credentials. You have to be incredibly careful about how you sandbox those agents.
That is the part that scares me. It is all fun and games until your AI agent accidentally deletes your production database because it misunderstood a "dead code" prompt. I think the "verification bottleneck" is going to be the biggest challenge for the next few years. We have the speed, but do we have the safety?
That is where the "middle ground" of the TUI shines. It keeps the human in the loop. You are not just firing off a command and hoping for the best; you are navigating a visual interface that shows you the implications of your actions before you commit them. It is the best of both worlds. It is the dashboard that lets you see the engine while you are driving at two hundred miles per hour.
Well, I think we have covered a lot of ground today. From Rust-based multiplexers to GPU-accelerated terminals and AI agents running in the cloud, the terminal in twenty twenty-six is a wild place. It is definitely not your grandfather's green-on-black command line anymore.
Not at all. It is a high-performance, multi-modal workspace that is finally starting to bridge that gap Daniel asked about. Whether you are a minimalist or a platform power user, there has never been a better time to be a terminal dweller. We are seeing the terminal evolve into the operating system of the AI era.
I am going to go try and find that one tab I lost three hours ago. I think it is hiding behind my third instance of lazygit.
Good luck with that. Before we go, a big thanks to our producer Hilbert Flumingtop for keeping everything running smoothly behind the scenes.
And a massive thank you to Modal for sponsoring the show and providing the GPU credits that power our research and this very conversation. They are doing incredible work in the serverless GPU space, which, coincidentally, is exactly the kind of infrastructure that powers these new agentic development environments. If you want to see how the "Oz" platform or other ADEs actually function at scale, Modal is the place to look.
This has been My Weird Prompts. If you enjoyed the deep dive into the terminal landscape, a quick review on your favorite podcast app really helps us get the word out to more developers.
We will be back next time with another deep dive into whatever Daniel throws our way. Until then, keep your latency low and your sessions persistent.
See you next time.
Goodbye.
