Claude Code

Key Features

Claude Code isn't a wrapper around an LLM. It's a fully realized AI development environment. Here's what ships in the source:

What is Claude Code?

Think of Claude Code less as a chatbot and more as a coworker who can actually touch your filesystem. It reads files, runs shell commands, browses the web, edits code, makes git commits, and orchestrates other AI agents directly from a single terminal session. The codebase behind it is a TypeScript monolith (~12,000 lines across 332+ modules) that runs on Bun and renders its UI using React. In a terminal. With hooks. Yes, really.

Codebase Overview

The source is organized into a flat-ish top-level directory with clearly named subdirectories for each system. Here are the most important entry points and directories:

Technology Stack

How It Works: The Big Picture

Every time you type a message, this is what happens under the hood. It is not magic, but rather it is a well-structured loop that any developer can read and understand:

The interactive REPL path renders each step with a rich Ink UI: tool use messages appear as they stream, progress spinners run during long operations, and the user can interrupt at any time. The headless SDK path (via QueryEngine) exposes the same pipeline as an async generator yielding SDKMessage events, suitable for programmatic embedding in other tools.

Built-in Safety

Every tool call passes through a layered permission system before execution. In the default interactive mode, the user is prompted to approve dangerous operations. The permission system supports configurable allow/deny rules, auto-approval modes, and even a lightweight LLM-based classifier that can make real-time security decisions in automated workflows.

Explore the Documentation

Each section below covers one piece of the puzzle. Start with Architecture if you're new, or jump straight to Tools or Security if you know what you're looking for.

Feature Flags

Several features are gated by Bun's dead-code elimination via feature() calls in tools.ts and query.ts. Features with this flag are literally removed from the compiled binary when disabled — zero bytes, zero runtime cost.

Startup Sequence

The main.tsx entry point uses a clever trick to optimize startup time: several expensive async operations are fired before imports complete using top-level side effects. Here is the sequence in chronological order:

1. 1
   Profile checkpoint profileCheckpoint('main_tsx_entry') marks the entry timestamp before any module evaluation begins, enabling startup profiling.
2. 2
   MDM raw read (parallel) startMdmRawRead() fires MDM policy subprocess reads (plutil on macOS, reg query on Windows) so they run concurrently with the remaining ~135ms of module initialization.
3. 3
   Keychain prefetch (parallel) startKeychainPrefetch() fires both macOS keychain reads (OAuth token + legacy API key) in parallel. Without this, they would execute sequentially via sync spawn, costing ~65ms on every macOS startup.
4. 4
   CLI argument parsing Commander.js parses argv and routes to the appropriate sub-command (REPL, print, chat, etc.).
5. 5
   Initialization init() bootstraps auth, config, GrowthBook feature flags, MCP connections, tool list, and system prompt.
6. 6
   REPL launch or headless query Depending on the invocation, either launches the Ink REPL (launchRepl()) or runs a single query through QueryEngine.

Key Design Decisions

Several architectural choices stand out when reading the codebase:

• Bun as bundler + runtime: By using Bun's macro features for conditional compilation, Anthropic can strip out beta features (like 'coordinator mode') entirely at build time, keeping the final binary fast and lean.
• React for the terminal: React in a terminal sounds bizarre until you try to build a streaming, interactive CLI with nested tool progress and inline diffs. Then it makes total sense.
• Single source of truth for tools: The same tool object defines the API schema, validates parameters, checks user permissions, renders the UI, and reports progress. It eliminates massive amounts of boilerplate.
• Two-path architecture: Code reuse at its finest. The interactive REPL and the programmatic SDK both wrap the exact same core pipeline (query.ts), just rendering the output differently.
• MCP as the extension mechanism: Instead of building a bespoke plugin system, they lean hard into the Model Context Protocol. You can hook into Claude Code using any external tool server without touching the core code.