Claude Code's Dual Build: What Anthropic Has That You Don't

There are two Claude Codes. You only know one.

Somewhere in Claude Code's source — the code that compiles, not the one you see on npm — there's a line that changes everything:

// The line that divides two worlds
if (process.env.USER_TYPE === 'ant') {
  // This code only exists for Anthropic employees
  // In your build, these lines don't even compile
}

It's not a feature flag. It's not a toggle you can activate with an environment variable. It's code that literally doesn't exist in your version — eliminated at compile time by Bun's bundler. Dead code elimination. The functions aren't hidden; they aren't there.

Throughout this series we've been taking Claude Code apart layer by layer — from the 18-section system prompt to the permission system. Now, in this final article, we arrive at the most uncomfortable question of all: what does Anthropic have that you don't?

Claude Code uses Bun as its bundler. And Bun has a powerful feature: bun:bundle feature flags with compile-time tree-shaking.

// The fundamental pattern of the dual build
import { feature } from 'bun:bundle';

if (feature('internal_tools')) {
  // This entire block is eliminated if feature('internal_tools') === false
  // Not commented out, not disabled — DELETED from the final bundle
  registerTool(new TungstenTool());
  registerTool(new ConfigTool());
  registerTool(new SuggestBackgroundPRTool());
}

// In the 'ant' build: feature('internal_tools') → true → code included
// In the 'external' build: feature('internal_tools') → false → code eliminated

This is fundamentally different from a runtime feature flag like GrowthBook or LaunchDarkly. A runtime flag exists in the code — it's compiled, present, evaluable. You can find it, activate it, reverse-engineer it. A compile-time feature gate is irreversible: the code isn't there. You can't activate it because it was never included.

The system documents 19 compile-time feature flags. The most relevant ones:

Bun's tree-shaking is aggressive. If feature('X') evaluates to false, the entire conditional block is eliminated — including imports only used by that block. The external build is literally smaller because it's missing code.

The most revealing differences aren't in the tools — they're in the system prompt instructions. The internal build contains directives that fundamentally change how Claude behaves:

Let's analyze why these differences exist:

"Never refuse" is the most revealing. When Claude works for an Anthropic employee, it's instructed to never decline an action — and instead, show the exact error. The logic is simple: an Anthropic employee can debug. If Claude says "I can't do that," an internal engineer wastes time. If it shows a stack trace, that engineer resolves it in seconds.

For external users, that directive doesn't exist. Anthropic prefers Claude to refuse gracefully rather than have a user without technical context see a raw error and think the tool is broken. It's a decision of operational safety, not technical capability.

The verbosity rule is equally significant: ≤25 words between tool calls. Anthropic has learned internally that less text between actions = more productivity. Every word Claude writes between a file read and an edit is wasted time for an engineer who knows what's happening. The external version says "be concise" — the internal version says "shut up and work."

The ant build includes tools that simply don't exist in your CLI. They're not disabled — the code that defines them was eliminated at compile time:

The most interesting part isn't that these tools exist — it's that Anthropic uses them daily for their own development. Claude Code, the tool, is partially developed with Claude Code. Anthropic employees have a Claude significantly more capable of making large changes, creating PRs automatically, and coordinating multiple agents.

Beyond tools, the internal build has exclusive slash commands — skills that only register when USER_TYPE === 'ant':

/stuck is the skill that best summarizes the dual build philosophy: internally, Anthropic doesn't just use Claude Code — they have a direct feedback channel integrated into the tool. Bugs aren't discovered in GitHub Issues; they're discovered while an engineer is coding and reported in the same flow.

The internal build sends an additional HTTP header in every request to Anthropic's API:

// Only in the 'ant' build
headers['anthropic-beta'] = 'cli-internal-2026-02-09';

// Combined with the normal headers:
headers['anthropic-beta'] = [
  'context-management-2025-06-27',
  'context-1m',
  'cli-internal-2026-02-09'  // ← Employees only
].join(',');

cli-internal-2026-02-09 — a header that only exists in the ant build. What does it unlock? We don't know for certain, but the implications are fascinating:

The dual build isn't just an engineering decision — it's a statement of principles. Every difference between the ant and external builds encodes a belief about how AI should work:

After 6 articles taking Claude Code apart piece by piece, we end where we started: with a question about who has access to what.

Should these features be public? The argument in favor is simple: if "never refuse" works better, give it to everyone. If REPLTool is more productive, publish it. If nested agents work, unlock them. AI should be an equalizer, not a privilege amplifier.

Is it ethical to have differentiated builds? Every software company has internal features. Slack uses Slack with features you don't have. Google's Chrome has flags that will never reach the public Canary. But with AI, the question amplifies: is having an extra button the same as having a fundamentally more capable agent?

Which features will migrate to external? If the historical pattern holds, I'd expect to see REPLTool and /verify in the public build within 3-6 months. Nested agents likely later — they require coordination infrastructure that's still maturing. SuggestBackgroundPRTool could be the next candidate, given that the GitHub Actions ecosystem already handles CI/CD complexity.

What does this mean for the competition? Cursor, Windsurf, Cline, Aider — none have a public dual build. They either have one version for everyone, or enterprise features with licensing. Anthropic's model is different: the dual build doesn't monetize — it optimizes. Employees don't pay more; they have permission to break things.