You Subscribed to 5 AI Coding Assistants, But Only Used 1's Worth of Efficiency — The Problem Is Not the Model

A counterintuitive phenomenon is happening: the stronger the AI coding models get, the higher the switching cost for developers.

Claude is good for frontend, switch to DeepSeek for backend, then open Kimi for long documents, GLM for Chinese NLP. Each model has its own API format, billing logic, and toolchain ecosystem. You think you're picking the most suitable weapon, but in reality, you might spend more time switching than writing code.

This isn't your problem; it's a tool architecture problem.

CodeWhale with 39k Stars attempts to solve this with a single terminal window. But what's more worth discussing than "one terminal running all models" is the design philosophy behind it — and the problems it couldn't solve.

A Dispatch Center, Not a Dedicated Line

The AI programming tool market is splitting into two routes.

Dedicated Line: Claude Code locks into the Anthropic ecosystem, Codex CLI is tied to OpenAI, Gemini CLI only runs Google models. The advantage is deep optimization; the disadvantage is that your tech stack is locked in by the vendor.

Dispatch Center: CodeWhale takes the other path. It positions itself as a "model router": you say "use DeepSeek", it automatically matches the API address, model name, billing rules, and communication protocol. The core component is called Route Resolver, which essentially shields the differences between various APIs.

This idea isn't new — Nginx does reverse proxying, Kong does API gateways — both are about "unifying the entry point to shield backend differences". But in the AI programming field, until the end of 2025, no one had done this. Because each model has different context lengths, inference methods, and tool calling protocols, the difficulty of creating a unified abstraction layer far exceeds that of an HTTP proxy.

To what extent has CodeWhale achieved this? It adapts DeepSeek's max_tokens, Claude's max_tokens_to_sample, and Ollama's local inference. It even calculates billing differences — DeepSeek charges by token, Kimi by character, Ollama is free.

But the dispatch center route comes with a natural cost: depth yields to breadth. You can run Claude in CodeWhale, but you'll never get the deeply coupled experience of Claude Code with the Anthropic API (like native support for Claude's extended thinking streaming output). This is a tradeoff, not a flaw.

The Constitution Is Not a Decoration

CodeWhale has a design that sounds academic — Nested Constitution.

The name is intimidating, but the problem it solves is real: when system prompts, project specifications, and historical memory conflict, who has the final say?

Claude Code relies on the model itself to judge priorities. So does Cursor. This essentially makes the athlete also the referee — the model naturally tends to follow the latest instruction, even if it contradicts project specifications.

CodeWhale's approach is to hardcode the priority chain: built-in constitution > user global rules > project local rules > memory information. It doesn't let the model guess; it's hardcoded at the code level.

This idea comes from a simple engineering intuition: determinism is better than cleverness. When rules conflict, predictable behavior is more reliable than "what the model thinks is best". Especially in large team collaboration, a deterministic error is easier to debug than an unpredictable correct outcome.

But hardcoded priority also has boundaries. If your project specification itself is contradictory (two contributors wrote conflicting rules), the constitution only ensures one wins — not necessarily the right one.

Three Gears, One Brake

CodeWhale's three safety modes might be its most discussed design:

• Plan: Read-only, research mode
• Agent: Ask for permission at every step
• YOLO: Fully automatic, you bear the consequences

This design isn't unique to CodeWhale. Claude Code has --dangerously-skip-permissions, Aider has --yes-always. But CodeWhale makes it a first-class citizen — not a hidden CLI flag, but an explicit toggle in the TUI interface.

Behind this, an industry consensus is forming: The danger of AI coding tools isn't that they make mistakes, but that you don't know what they're doing.

This year, UpGuard analyzed 18,470 Claude Code configuration files on GitHub and found that many developers granted AI YOLO-level permissions: arbitrary code execution, unrestricted file deletion, unlimited network access. The report used an alarming metaphor — if these permissions were chained, they could create "sandworm-style" attacks that self-propagate through the developer ecosystem via vibe-coding permissions.

By putting YOLO mode in plain sight, CodeWhale reminds you: You can go full speed anytime, but you know you're going full speed.

A Law Graduate, a Whale, and a Controversy

CodeWhale's author, Hunter Bown, is not your typical Silicon Valley engineer. He's an American law graduate, self-proclaimed "Whale Brother" (Hmbown = Hunter the Whale Brother).

This background isn't gossip — it explains some of CodeWhale's design intuitions. A concept like "Nested Constitution" likely wouldn't occur to a pure CS graduate. Legal training gives a natural sensitivity to arbitration mechanisms when rules conflict.

In May of this year, Hunter came to China. He tweeted in Chinese on X: "Hello whale brothers, I'm the American guy who made DeepSeek-TUI." That tweet got 38k views, and Chinese developers affectionately called him Brother Whale.

But the China trip ended in controversy. Hunter cut short his trip, claiming he was "used." Details vary, but this event reveals an awkward situation for open-source projects: When you go from a personal project to community infrastructure, your authorship no longer belongs solely to you.

The rename from deepseek-tui to CodeWhale also reflects this tension — a small tool originally optimized for DeepSeek grew into a routing platform supporting dozens of models. The name changed, and community expectations changed too. Someone on GitHub asked: "After the rename, are my sessions and skills still there?" — This is not just a technical migration issue; it's a trust migration issue.

Another Bet on the Same Starting Line

When discussing CodeWhale, we can't ignore Reasonix (formerly DeepSeek Reasonix). Both projects started from the DeepSeek ecosystem in the same year and month, but bet on completely opposite paths.

CodeWhale's path is "feature explosion": multi-model, sub-agent concurrency, LSP diagnostics, sandbox isolation, skill marketplace, Headless API. It aims to be a Swiss Army knife in the terminal.

Reasonix's path is "economic discipline": the entire architecture is designed around DeepSeek's prefix caching mechanism. One user, one day, 435 million tokens, 99.82% cache hit rate, $12 — without caching, the same amount would cost $61. This number isn't hype; it's a reproducible benchmark.

These two paths represent the core divide in AI programming tools: Do you want a universal platform that can do everything, or a specialized tool that does one thing exceptionally well?

The answer depends on who you are. If you're an individual developer or heavy user of model APIs, Reasonix's cost control might be more appealing. If you're in a team needing flexible model switching and sub-agent concurrency for large codebases, CodeWhale's dispatch capabilities are more practical.

The Terminal Isn't Outdated, But It's Not a Silver Bullet Either

The original article has a good point: "Clicking buttons is humans serving machines; typing commands is machines serving humans."

But that's only half right. The terminal is indeed one of the most efficient human-computer interaction methods — for experienced users. For most developers, the barrier to the terminal is real. CodeWhale's TUI interface built with Ratatui lowers this barrier, but "lower" is not "eliminate."

A more fundamental issue is: Model routing solves "switching cost," not "model capability." You can use five models simultaneously in CodeWhale, but if each model's understanding of your codebase is shallow, five shallow understandings don't add up to one deep understanding.

This is the ceiling of the dispatch center route. It lets you use more models, but it can't make the models understand your code better.

GitHub Address: https://github.com/Hmbown/CodeWhale

If you switch between three or more AI programming tools every day, it's worth 10 minutes to try. If you only use one model and it works well for you, keep using it — the purpose of tools is to solve problems, not to create choices.