Don't be a Vibe Coding Passenger. Practice TUI Coding.

There’s a way of building with AI where you describe what you want and hope for the best. Where the AI writes the code, picks the architecture, decides what to test. You watch it happen. Maybe it works. You’re not entirely sure why. But it shipped, and that feels like progress.

You’re a passenger on a ship you can’t pilot. And everything is fine–until it isn’t.

They call it vibe coding. And for a lot of people, it works fine.

But if you’ve been building software for years–if you have opinions about error handling, if you care about what happens when things fail at 3 AM, if you’ve been burned enough times to know that “it works on my machine” is the beginning of a story, not the end of one–vibe coding feels like being a passenger in your own cockpit.

TUI (Terminal User Interface, “tuwy”) coding is what happens when experienced developers refuse to be passengers.

What TUI coding looks like

Terminal. Not a chat window. Not a sidebar. A terminal, where you can see every file change, every command, every decision your agents make.

Multiple agents, each with a role. A lead that coordinates. A coder that writes. A researcher that explores. A writer that drafts. Each one running in its own tmux pane, with its own context, its own working directory, its own permission level. You define the topology in YAML. One command boots the whole squad.

Shared state files on disk–markdown, plain text, things you can read with cat and edit with your hands. No proprietary formats. No database you can’t inspect.

Slash commands. System prompts. Custom skills you write yourself. Not plugins from a marketplace. Your tools, built for your workflow.

The developer is the architect. The agents are the crew. You direct. They execute. You review every pull request, every file change, every architectural decision. Nothing ships without your eyes on it.

The line between vibe and TUI

The distinction isn’t about tools. It’s about posture.

Vibe coding says: tell the AI what you want, trust the output, ship it.

TUI coding says: direct the AI precisely, verify the output, understand what shipped and why.

Vibe coding optimizes for speed to first result. TUI coding optimizes for speed to correct result. The difference shows up at 2 AM when something breaks and you need to know what your system actually does.

One puts the developer in the audience. The other puts the developer in the cockpit.

Both use AI. Both move fast. But one of them knows where it’s going.

Why the terminal

The terminal isn’t nostalgia. It’s precision.

Every agent has a name, a pane, a session. You can send a command to any specific agent from anywhere: tmux send-keys -t coder:1.1 '/sync' Enter. Try doing that with a chat sidebar.

Pipe the output of one tool into the input of another. Write scripts that orchestrate your agents. The terminal is programmable in a way that GUIs never will be.

tmux sessions survive crashes, editor restarts, SSH disconnects. Your agent conversation doesn’t die because you closed a tab. Detach, reattach, pick up where you left off.

git diff shows you exactly what changed. tmux capture-pane shows you what any agent is doing right now. Nothing is hidden behind a loading spinner.

Your entire agent topology is a YAML file. Version-controlled. Shareable. tmuxinator start and a new developer has the same setup you do.

TUI coding is not anti-AI

TUI coding is AI-native to its core. This isn’t a rejection of AI tools. It’s a rejection of AI tools that hide what they’re doing.

TUI coders run more AI agents, more often, with more coordination than most vibe coders ever will. The difference is that every agent action is visible, reviewable, and under the developer’s direction.

We use AI the way a general contractor uses a crew. Not by standing back and hoping the house gets built right. By being on site, reading the blueprints, checking the work, and making the calls that require judgment.

The AI does the heavy lifting. The developer does the thinking.

Who this is for

You might be a TUI coder if:

You run multiple AI agents simultaneously and coordinate them through your terminal
You’ve written custom system prompts, slash commands, or skills for your agents
You review every file change your agents make before it ships
You use tmux, screen, or another multiplexer as your development environment
You chose a CLI-based AI tool over a GUI-based one on purpose
You have opinions about agent permissions and you enforce them
You care about what happens when things break, not just when things work
You’ve been writing code long enough to know that “it works” isn’t the same as “it’s right”

If this sounds like you, you’ve been doing TUI coding. You just didn’t have the name for it yet.

The definition

TUI coding is terminal-native, precision-first, agentic software development where the developer directs, reviews, and orchestrates AI agents through the command line. The developer is the architect. The agents are the crew. Every action is visible. Every decision is deliberate. Nothing ships on vibes alone.