Claude Code's Source Code Just Leaked. Here Are 10 Things It Reveals About How You Should Be Using It.

Most people run Claude Code as a single thread. One conversation, one task at a time.

The architecture supports three execution models for sub-agents — and because they share the prompt cache, running multiple agents is practically free compared to running them sequentially.

Fork inherits the parent's context and is cache-optimised. Use it for quick, focused tasks like "search the codebase for X" or "read these three files and summarise."

Teammate runs in a separate terminal pane with a file-based mailbox for communication. Use it for longer independent tasks that don't need your parent context.

Worktree gives each agent its own git worktree and isolated branch. Use it for parallel code changes that would conflict if done in the same working directory.

The source code also reveals sub-agent model overrides — you can choose which model each sub-agent uses independently from your primary model. Run Opus for your main thread, Haiku for quick lookups. This is a significant lever for managing cost and performance.

Think about your workflows. How many tasks are you running sequentially that could run in parallel?

If you are clicking "Allow" multiple times per session, you have not configured your permissions properly.

The permission system has a five-level cascade: policy → flag → local → project → user. Higher levels override lower ones. Settings at the organisation level take precedence over everything.

There are three modes: bypass (dangerous — no checks), allowEdits (moderate — auto-approves file edits, prompts for bash), and auto (recommended — an LLM classifier decides based on the action's risk).

The real power is in glob patterns in your settings.json. You can allowlist specific tools, specific file paths, and specific bash command patterns for your recurring workflows.

Set this up once per project. Save it in .claude/settings.json so it persists. Stop clicking.

The default context window is 200K tokens. You can opt in to 1M by adding [1m] to your model suffix. Most people don't know this exists.

But more context is not always better. The best users practice what Nate Herk calls context hygiene — being intentional about what files are in context, what memory is being injected, when to compact, and when to resume.

There are five compaction strategies built into the architecture:

Micro-compact happens automatically when your context fills up. You don't control this directly.

The /compact command is your manual save point. Use it with a prompt to preserve specific context: /compact keep the database migration details.

Context collapse handles large tool results. They are stored to disk with only an 8KB preview sent to the model. This is why reading a massive file doesn't blow your context.

Session memory extracts key context across compactions — task specs, file lists, workflow state, errors, and learnings. It persists even when the conversation is compressed.

PTL truncation manages the overall prompt token limit to keep you within bounds.

The discipline is simple: audit your context with /context, compact regularly with specific prompts, and use the 1M window only when you genuinely need it.

The hook system is one of the most powerful and least-used features in Claude Code.

There are 25+ lifecycle events: SessionStart, SessionEnd, UserPromptSubmit, PreToolUse, PostToolUse, and many more. Each event can trigger one of five hook types: command, prompt, agent, HTTP, or function.

Here is why this matters:

UserPromptSubmit can inject additionalContext into every message automatically. That means you can pull in live data from external systems — CRM status, calendar, project state — without manually pasting it.

PreToolUse lets you intercept actions before they happen. Auto-lint before file writes. Run tests before commits. Block dangerous commands.

PostToolUse triggers follow-up actions. After a file edit, run the test suite. After a commit, send a Slack notification. After a deployment, update your project tracker.

This is how you turn Claude Code from a coding assistant into a configurable execution environment. The hooks make it yours.

Every session is saved as JSONL at ~/.claude/projects/{hash}/{sessionId}.jsonl. Most people never touch these.

Three commands change everything:

--continue resumes your last session exactly where you left off. No re-explaining. No lost context.

--resume lets you pick a specific past session. Useful when you're switching between multiple workstreams.

--fork-session branches from a past conversation. You keep all the context but start a new thread. This is powerful for exploring alternative approaches without losing your main line of work.

But here is the real game-changer: MEMORY.md.

Create a dedicated MEMORY.md file for saving preferences, learnings, and patterns across sessions. Claude Code's auto-memory system can write to this automatically. But you can also structure it yourself.

Think of it as a persistent knowledge layer that compounds over time. Every session deposits knowledge the next session builds on. Your preferences, your conventions, your past decisions — all available automatically.

This is the difference between a tool that forgets and a tool that learns.

Claude Code has 60+ built-in tools, partitioned into two categories:

Concurrent (read-only): Read, Glob, Grep, WebFetch, Agent, WebSearch. These run in parallel. Multiple file reads happen simultaneously. No configuration needed.

Serial (mutating): Edit, Write, Bash, NotebookEdit. These queue for safety. One write at a time, in order.

This is automatic. You don't configure it. But understanding it changes how you structure your prompts. Ask Claude to "read these five files" and they all load in parallel. Ask it to "edit these five files" and they queue safely.

The real extension point is MCP (Model Context Protocol). MCP servers connect Claude Code to external systems — databases, cloud APIs, CI/CD pipelines, Slack, browsers, CRMs, anything with an API.

The source reveals deferred loading: connecting five MCP servers costs nothing until one is actually called. So connect everything. Only pay for what you use.

The .env.example also shows Claude Code can route through direct Anthropic access, AWS Bedrock, Google Vertex AI, or Azure Foundry. Multiple cloud backends, configurable per deployment.

Everything in insights 1-9 describes the layers. This insight shows what it looks like when you wire them all together.

I have been running this system for six months. Before the source code leaked. Before anyone was talking about it. The leak just validated the architecture.

Here is the pattern:

Every project gets a COS.yaml — a Client Operating System file. Single source of truth. Key data, current status, position within my business framework. One file tells any AI assistant exactly where this project stands.

Different project types get different frameworks. A revenue client gets the TORQUE methodology. An internal product gets a different framework. Each framework deploys into a hidden folder (like .njin-method/) with its own scripts, structure, and config.

Frameworks deploy agents. The hidden folder contains scripts that spin up the relevant agents for that project type. A revenue client might get a playbook agent, a CRM agent, and a dashboard agent. Each agent references specific skills.

Skills reference templates, workflows, and MCPs. A playbook skill knows how to generate revenue playbooks from templates. A CRM skill connects to GoHighLevel via MCP. A reporting skill pulls data from Notion.

Everything is linked. Framework → Agents → Skills → Templates → Workflows → MCPs. Change the framework, and the entire downstream chain updates.

At the top sits Cowork — deployed at the root Projects level. It reads all COS files across all clients. It knows where every project stands, what is overdue, what needs attention. It references Notion for task management and Reclaim for calendar/time budgets.

This is not a vision of the future. This is running in production today. The source code leak just showed everyone else what the architecture was designed to support.

The gap between how most people use Claude Code and how it was designed to be used is enormous. That gap is your advantage.