In 2025, something quietly changed about the terminal. It didn’t happen all at once. Claude Code arrived, then Cursor’s terminal mode, then AI agents running as background workers, streaming output continuously. Token-saving proxies started intercepting shell commands. Suddenly the terminal wasn’t just where you typed commands - it was where AI lived.
I’d been on iTerm2 since 2015. Back then, switching from Linux to macOS, it was the first thing every senior engineer told me to install. For a decade it was invisible infrastructure - just there, doing its job. I didn’t think about it.
AI made me think about it again. The lags. The memory. The realization that I couldn’t script it properly. And then, in a move that felt almost too on-brand, I had Claude Code do the migration for me.
This is that story - and what an AI-optimised terminal actually looks like.
2015: When iTerm2 Was Still The Answer
[
When I made the jump from Linux to macOS in 2015, the terminal was the first thing I felt homesick about. Linux gave you a raw, fast shell. macOS’s default Terminal.app felt like a toy.
iTerm2 fixed that. Split panes, saved profiles, a hotkey window that dropped down on a keystroke, shell integration that tracked your working directory across tabs. For a developer coming from Linux, it was a genuine power tool. I set it up once and stopped thinking about it. That’s the highest praise you can give infrastructure.
It worked invisibly for nearly a decade. Then three things started going wrong.
The terminal started lagging. Long output - build logs, test runs, streaming responses - would cause the window to stutter. Scrolling froze for a beat. The cursor fell behind what I was typing. This wasn’t dramatic, just irritating - until I started running Claude Code sessions. AI generates output fast, and iTerm2’s CPU-based renderer couldn’t keep up. My laptop fans would spin up during what was supposed to be a quiet coding session.
My machine got sluggish. Nothing I could point to directly, just swap pressure, slower context switches, the general feeling of running out of headroom. When I looked more carefully, iTerm2 was quietly eating 300-400MB across my open panes - on top of Cursor, Claude Code, Docker, and a local Redis already competing for memory.
I couldn’t script it. I wanted to automate my window layout, send commands programmatically from scripts, have AI tools interact with the terminal as an API rather than just a UI. iTerm2 has AppleScript. That’s its answer to programmability. No socket, no remote protocol, no way to open a tab from a shell script without writing brittle AppleScript glue.
None of these were dealbreakers on their own. Together, they were death by a thousand cuts - and all three had the same root cause: AI had moved into my terminal, and iTerm2 wasn’t built for a roommate.
It’s not that iTerm2 got worse. It’s that the job description changed. In 2015, a terminal needed to display text reliably, manage tabs and splits, and stay out of the way. In 2026, it also needs to handle continuous high-volume output without stuttering, run lean alongside a full AI toolchain, and expose enough programmability for AI tools to treat it as a first-class interface. iTerm2 was built for the first set of requirements. Kitty was built closer to the second.
The Migration That Migrated Itself
Here is the prompt I gave Claude Code: “Install Kitty and set it up the same way I have iTerm2 set up. Make it default for all editors and the system.”
That’s it. What happened next took under 10 minutes of AI execution time.
Claude Code read my iTerm2 preferences using defaults read - the macOS command that dumps application settings from their binary plist format. From that output it extracted my font (Monaco 12), my color scheme (a custom light theme), window dimensions, and every keybinding I had configured.
It installed Kitty via Homebrew and wrote a kitty.conf from scratch - ported colors to Kitty’s plain text format, mapped my split-pane shortcuts (Cmd+D for vertical, Cmd+Shift+D for horizontal), carried over the visual bell, inactive pane dimming, the lot. Then it opened my VS Code and Cursor settings files, found terminal.external.osxExec: "iTerm.app" in both, and changed them to "kitty.app". Finally it installed duti and registered Kitty as the default handler for shell file types using its bundle ID (net.kovidgoyal.kitty).
A human doing this manually - reading iTerm2 documentation, decoding a binary plist, translating color values between two different config formats, hunting for the right duti incantation - would spend an hour. Easily. I know because I’ve done similar migrations before.
Config migration is exactly the kind of task AI handles better than humans: tedious, well-documented, error-prone, with no room for creativity. AI doesn’t get bored halfway through and start approximating. It does all ten steps the same way.
The irony wasn’t lost on me. I was using AI to build a terminal optimised for AI. The ouroboros of developer tooling.
Thanks for reading Olko - Tech/Engineering! Subscribe for free to receive new posts and support my work.
What an AI-Optimised Terminal Looks Like in 2026
The full config is here. What follows is the philosophy behind it.
The emulator: Kitty
Kitty is GPU-accelerated. This matters more than it sounds. When Claude Code streams a long response, or a BullMQ worker dumps a thousand lines of agent output, the renderer doesn’t choke. CPU usage stays flat. The fans stay quiet. That was the first thing I noticed after switching.
The second thing: Kitty has a remote control protocol. With allow_remote_control yes and a unix socket, other processes can send commands to Kitty - open a tab, split a pane, send keystrokes - without any GUI automation. This is the terminal as an API, not just a UI. AI tools can drive it programmatically.
The third thing, which turns out to matter most: the config is a plain text file. ~/.config/kitty/kitty.conf. One file. Human-readable. Version-controllable. And - this is the key - fully legible to AI tools. iTerm2’s configuration lives in a binary plist that’s opaque to everything except iTerm2 itself. Kitty’s config is just text with clear semantics. That’s what made the migration possible in the first place.
The AI layer
On top of Kitty, I run RTK - a personal tool that acts as a transparent proxy between Claude Code and the shell, compressing command output before it hits the token counter. It saves 60-90% on tokens for routine dev operations, wired in via Claude Code hooks so it’s invisible in normal use.
Claude Code runs with shell_integration enabled, which gives it awareness of the terminal state - working directory, running processes, exit codes. Cursor and VS Code both point to Kitty as their external terminal. The BullMQ agent workers that run my AI simulation backend stream their output through Kitty’s GPU renderer.
The most useful consequence of a plain text config: the terminal is now AI-maintained. Need a new keybinding? I describe it to Claude Code. Want to port a color scheme from another tool? It reads the source format and writes the Kitty equivalent. The config is a living document that gets better over time without me manually editing it.
The shell layer
My zsh setup - Powerlevel10k, fzf, Atuin for shell history, zsh-autosuggestions - moved from iTerm2 to Kitty unchanged. This layer is terminal-agnostic. It doesn’t care what’s rendering it.
That’s the point of the whole stack: Kitty renders, zsh orchestrates, AI tools inhabit. Each layer is independently replaceable.
The Tool That Disappears
The best infrastructure is invisible. You don’t think about your database when you’re writing a query; you think about the data. You don’t think about your terminal when you’re working; you think about the code.
iTerm2 was invisible for ten years. Then the work changed, and it became visible - in the lag, the memory pressure, the AppleScript dead ends. Kitty is invisible again.
That said: Kitty is not a drop-in replacement for everyone. There’s no GUI preferences pane - you edit a text file. The macOS integration is less polished; some things that just work in iTerm2 require config tweaks in Kitty. If you rely heavily on tmux integration, iTerm2’s implementation is more mature. And if you’re not running AI agents, worker processes, or heavy streaming output in your terminal, you probably won’t feel the difference. iTerm2 is still excellent software.
But if your terminal has become an AI workspace - and for a growing number of engineers it has, or soon will - it’s worth thinking about whether your emulator was built for that world.
Your terminal is the last tool that should slow down your AI.
Top comments (0)