My Terminal Setup for AI Agentic Coding

The bottleneck in AI-assisted coding is no longer the agent itself. Tools like Claude Code, Aider, and Codex CLI are remarkably capable. The real constraint is the human’s ability to orchestrate multiple agents working in parallel - watching their output, steering them when they drift, and merging their work together.

I’ve landed on a terminal-first setup that makes this manageable. Four tools, all lightweight, all composable: Ghostty for the terminal, Yazi for file navigation, Fish for the shell, and LazyGit for git operations. Here’s why each one earns its place.

Why the Terminal for Agentic Coding

AI coding agents are CLI-native. They read files, run commands, and produce output in a terminal. When you want to run three agents simultaneously - one building a feature, one fixing a bug, one writing tests - you need three shell sessions running side by side.

An IDE can do this, but at a cost. VS Code with multiple integrated terminals, extensions, language servers, and the editor itself can easily consume 2-4 GB of RAM. That’s memory your AI agents could use instead. Every token of context, every API call, every file read competes for the same system resources.

A lightweight terminal setup flips this equation. The tools I use collectively consume a fraction of what a single Electron-based editor demands, leaving the machine’s resources available for what matters: the agents doing the actual work.

Ghostty - The Foundation

Ghostty is a GPU-accelerated terminal emulator that uses Metal on macOS and OpenGL on Linux. It’s written in Zig, and it’s fast - benchmarks show it rendering plain text around 4x faster than iTerm2 and Kitty, maintaining roughly 60fps even under heavy load.

For agentic workflows, the key feature is native splits and tabs. You don’t need tmux. Ghostty handles pane splitting at the application level, which means smooth rendering, proper font scaling, and no configuration ceremony. Open a new split, start an agent, and you’re running.

My typical layout is four panes:

• Top-left: Claude Code working on a feature branch
• Top-right: A second agent tackling a separate task
• Bottom-left: Yazi for monitoring file changes
• Bottom-right: LazyGit for reviewing and committing

When an LLM streams a long response, some terminals choke on the rapid output. Ghostty’s GPU rendering handles this without dropping frames or lagging, which matters when you’re watching multiple streams at once.

Yazi - Navigating While Agents Work

When three agents are modifying files across your codebase, you need a way to see what’s changing - fast. Yazi is a terminal file manager written in Rust with fully asynchronous I/O. Every operation is non-blocking, so navigating a large directory never stalls while a file preview loads in the background.

I keep Yazi open in one pane and use it to:

• Monitor changes as agents create and modify files in real time
• Preview files without opening them in an editor - Yazi renders syntax-highlighted code, images, and even PDFs inline
• Bulk rename when an agent generates files with naming conventions I want to adjust
• Jump between directories quickly using bookmarks and search

The plugin system (Lua-based) lets you customize Yazi to fit your workflow. I use a few plugins for git status indicators and quick directory jumping, but the defaults are already solid.

Fish Shell - Reducing Cognitive Load

When you’re switching between four terminal panes, each running different tasks, cognitive load adds up fast. You glance at a pane and need to remember what it was doing, re-orient, type a command, and move on.

Fish reduces this friction with features that work out of the box:

• Autosuggestions: Fish suggests the rest of your command in gray text based on history. You press the right arrow to accept. No plugin required.
• Syntax highlighting: Valid commands appear in one color, invalid ones in another. You catch typos before hitting enter.
• Tab completion: Fish parses man pages to generate completions automatically. Type a command, press tab, and get contextual options.

The critical difference from zsh is zero configuration. There’s no oh-my-zsh to install, no .zshrc to maintain, no plugin manager to update. Fish works immediately after installation. When you’re focused on orchestrating agents, the last thing you want is to debug your shell configuration.

LazyGit - Worktree-Based Parallel Development

This is where the setup really shines for parallel agentic work. LazyGit is a terminal UI for git, and its worktree support is what makes multi-agent development practical.

The pattern is straightforward: each agent works on a separate git worktree. A worktree is a linked copy of your repository that checks out a different branch in a different directory. Agent A works in ./feature-auth/ on the feat/auth branch. Agent B works in ./fix-perf/ on the fix/performance branch. They never touch each other’s files, so there are no merge conflicts during parallel work.

LazyGit makes managing this workflow visual and fast:

• Create worktrees with a single keypress (w)
• Switch between worktrees to review what each agent has done
• Interactive rebase to clean up an agent’s commit history before merging
• Visual diffs to inspect changes across branches side by side
• Undo/redo via reflog integration - if an agent produces something unexpected, press z to roll back

Without a visual git tool, managing multiple worktrees means juggling cd commands and git log outputs across directories. LazyGit collapses that into a single, navigable interface.

Putting It All Together

A typical session looks like this: I open Ghostty and split it into four panes. I create two worktrees with LazyGit - one for a feature, one for a bug fix. I start Claude Code in the top-left pane pointed at the feature worktree, and a second agent in the top-right pane pointed at the bug fix worktree. Bottom-left is Yazi, where I can browse both worktree directories and preview changes as they happen. Bottom-right is LazyGit, where I review diffs, stage changes, and eventually merge both branches.

The key insight is that none of these tools fight for resources. Ghostty, Yazi, Fish, and LazyGit are all compiled, native programs. No Electron runtime, no JVM, no Python interpreter eating memory in the background. The machine’s resources stay available for the AI agents, which is where the real compute happens.

Wrapping Up

The best agentic coding setup isn’t about which AI model you use - it’s about the human layer. Your ability to run multiple agents, monitor their output, course-correct when they drift, and merge their work cleanly determines how much you actually get done.

This stack is opinionated but minimal. Ghostty for rendering, Yazi for files, Fish for the shell, LazyGit for git. Each tool is fast, lightweight, and composable. If you’re running AI coding agents and haven’t tried a parallel terminal workflow, pick one of these tools and see how it changes your process.