Why does the most powerful AI look like 1985?

If you’ve been paying attention to the AI space lately, you might have noticed something strange. The most powerful tools—AI agents that can write code, manage files, search the web, and build entire applications—are running inside a terminal. A black screen. White text. No buttons, no hover states, no design system.

As designers, our first instinct might be to call this a UX failure. But I think it’s something more interesting than that. It’s a signal—and if we look closely, it tells us where design is heading next.

Text is the native language of AI

Large language models think in text. They read text, they produce text. The terminal is the most direct line between you and an AI agent—no abstraction layer, no translation, no GUI sitting in between. When you type a command and the agent responds, you’re communicating in its native tongue.

The agent gets full access to your file system, your project context, your tools—all through plain text. Nothing is lost in translation.

Speed of iteration beats polish—for now

We’re in a moment where the underlying technology changes every few weeks. New models, new capabilities, new paradigms. Building a polished GUI on top of something that might fundamentally shift next month is risky. Terminal tools can be built, tested, and shipped in hours. A well-designed GUI takes weeks—sometimes months.

The people building these AI tools aren’t ignoring design. They’re choosing speed over polish because the foundations are still moving. And in a race where the landscape changes this fast, shipping quickly is survival.

The audience is developers—for now

Right now, the most powerful AI agent tools still tend to surface in developer territory first—terminal-based, code-driven, deeply technical. That said, things are shifting fast. Tools like Notion already let you create agents through simple chat prompts. Claude itself now has Cowork for non-developers right alongside Claude Code for the terminal. The audience is widening. But if you look at where the most agentic capabilities tend to appear first—filesystem access, code execution, tool chaining—it’s still the CLI. The GUI catches up, but the terminal leads.

I’m seeing this play out at work too. I’ve been on a big AI project where developers led the initial design—they shipped fast, built what worked, and moved on to the next problem. We as designers came in later to uplift the quality bar, refine the experience, and make it feel right for people. That sequence wasn’t a failure of process. It was the natural rhythm of how new technology finds its shape.

When I see a tool that looks “unfriendly,” I’ve learned to ask: unfriendly to whom? A terminal is hostile to someone who’s never seen one. But to a developer, it’s a power tool—like a musician’s mixing board.

Something I discovered along the way

When I started using Claude Code in the terminal—I found myself picking up Git almost by accident. I needed it to manage my code, so I just started learning. And here’s what surprised me once I dug deeper: Git itself started life as a terminal-only tool. If you wanted to commit, branch, or merge, you typed commands into a black screen. Then over time, graphical interfaces like GitHub Desktop, Tower, and GitKraken came along and made the same power more visual, more approachable—without replacing the terminal underneath.

I’d never known that history before. But once I saw it, I couldn’t unsee the pattern:

CLI → GUI → Mainstream.

The terminal comes first. The GUI follows. Then everyone else catches up. I think AI agents are at that same moment right now—and it’s a fascinating space to be learning in as a designer.

So I started learning

All of this led me to just start. I built a small web app to help me learn terminal commands—through interactive browsable commands, gamification quizzes, and cheatsheets. It works on both mobile and desktop. Nothing fancy. Just a tool I wished I had when I first opened a terminal and had no idea what to type.

And here’s the part that makes me smile: I built the whole thing using that same Claude Code agent I mentioned—right there in the terminal. A designer, sitting in front of a black screen with white text, talking to an AI to build a tool that teaches him how to use that same black screen. The tool became its own proof of concept.

Try it yourself 👉 cli.bykocha.com

My thought?

The paradox isn’t that advanced AI runs in a primitive interface. The paradox is that we, as designers, have been so focused on graphical interfaces that we forgot—text was the original interface. And now, with AI, text is having its renaissance.

The terminal isn’t the end state. It’s the beginning. Learning it shouldn’t feel intimidating—it should feel like play. And I’m enjoying learning to navigate it now—imagining what design will replace it tomorrow.

Warmly,

Kocha 😊

‍