I Reverse-Engineered Claude Code, Made It 100x Better to Use, and Built 11 Systems That Make It 40% More Efficient

Published 2026-06-07

Parts of this post were written with assistance from Khlawde itself.

TLDR

I took the Claude Code source from the sourcemap leak, removed every artificial limit (4x output tokens, 3x search, 2.5x timeouts), ungated all 92+ feature flags and internal-only prompt enhancements, then built 11 background intelligence systems on top. It has a loop detector that catches the tool repeating itself and injects a circuit-breaker. A "scar tissue" system that remembers failures across sessions so it never makes the same mistake twice. Dead store elimination that treats conversations like compiler IR and reclaims 30-50% of the context window. An overnight autonomous engine that fixes TODOs and adds tests while you sleep. A self-evolving prompt system that A/B tests its own skill prompts with ELO ratings and auto-promotes winners. Net result: 20-40% fewer tokens per session, and a tool that genuinely gets better every time you use it.

Index

Background

You probably already know about the Claude Code sourcemap leak. I took the ~180K lines of TypeScript, reconstructed the build system, stubbed the ~15 internal @ant/* packages, and got it running on Bun. Build time: ~4 seconds, single ESM bundle.

What's interesting isn't the extraction, or even what I found inside. It's the tooling I was able to build on top of it which even Anthropic even hasn't built out yet.

The Great Unshackling

Philosophy

Stock Claude Code operates under conservative limits designed for Anthropic's pricing model and safety posture. These limits are not technical constraints. They're business decisions enforced in code. Since I'm using my own API keys (and paying per token anyway), these limits serve no purpose. The token cost increased will also be mitigated by optimizations later on.

Limits Raised

Parameter Stock Value Modified Value Multiplier
Default output tokens 8,000 32,000 4x
Escalated output tokens 64,000 128,000 2x
Web search max uses 8 25 3x
File read max tokens 25,000 60,000 2.4x
Tool result size (chars) 50,000 150,000 3x
Tool result size (tokens) 100,000 250,000 2.5x
Tool results per message 200,000 500,000 2.5x
Bash default timeout 2 min 5 min 2.5x
Bash max timeout 10 min 30 min 3x
Fork agent max turns 200 500 2.5x

Gates Removed

Subagent Thinking. Stock Claude Code strips extended reasoning from all subagent calls. This is a cost optimization that dramatically reduces subagent quality. I re-enabled thinking for every agent by removing the thinking: undefined override in the agent runner.

Nested Agent Spawning. Stock code prevents non-Anthropic users from spawning subagents inside subagents (recursive delegation). The gate is a simple USER_TYPE === 'ant' check. Removed.

Async Agent Tools. Background agents were restricted to a small tool allowlist. I added Agent, SendMessage, and task management tools to the async allowlist, enabling background workers to orchestrate other workers.

Internal Prompt Enhancements. Five system prompt improvements were gated behind an internal user check:

  1. Assertiveness (proactively flag misconceptions)
  2. Verification (verify before reporting complete)
  3. Comment discipline (default to no comments)
  4. Faithful reporting (never claim false passes)
  5. Numeric length anchors (word count targets between tool calls)

All ungated.

Feature Flags

All 92+ feature flags enabled unconditionally:

define: Object.fromEntries(
  ALL_FLAGS.map(flag => [`feature('${flag}')`, 'true'])
)

Notable flags include KAIROS (always-on autonomous assistant), ULTRAPLAN (Opus-powered planning), BUDDY (terminal tamagotchi), COORDINATOR_MODE (multi-agent orchestration), VOICE_MODE, WEB_BROWSER_TOOL, TOKEN_BUDGET, and CONTEXT_COLLAPSE.

Personality as Architecture

The Problem with Soft Prompting

Most personality customization relies on instructions in markdown files that load late in the system prompt. These instructions compete with (and are often overridden by) the system's own behavioral directives. They are suggestions, not identity.

Position Zero Injection

I created a hardcoded personality directive that is injected as the first element of the system prompt array. This means it loads before tool descriptions, behavioral instructions, safety guidelines, and any user-provided markdown.

The personality is not a suggestion like CLAUDE.md is. It is the foundational context through which all other instructions are interpreted. This allows for a "stretched" interpretation it's "hard" rules.

Self-Healing Mode

Since the early version was unstable, especially with it modifying itself and all, I built a PowerShell wrapper that catches crashes and spawns a background session to diagnose and fix the source. Up to 5 auto-fix cycles per crash.

Performance Optimizations

Six targeted optimizations that reduce latency and token usage without changing behavior:

System Prompt Compression (60% reduction)

The stock "doing-tasks" section contained ~1,750 words of verbose instruction. I compressed to ~300 words with identical semantic content. The "actions" section was compressed 70%. Combined savings: ~2,000 tokens per API call.

Tool Lookup O(1)

findToolByName() is called on every tool_use block during streaming response processing. Stock implementation: linear .find() over 50-100+ tools. My implementation: WeakMap-cached Map index, built once per tools array, O(1) lookup thereafter.

const toolIndexCache = new WeakMap<Tool[], Map<string, Tool>>()

export function findToolByName(tools: Tool[], name: string): Tool | undefined {
  let index = toolIndexCache.get(tools)
  if (!index) {
    index = new Map()
    for (const tool of tools) {
      index.set(tool.name, tool)
      for (const alias of tool.aliases ?? []) index.set(alias, tool)
    }
    toolIndexCache.set(tools, index)
  }
  return index.get(name)
}

Pre-Call Context Overflow Detection

Before each call, I estimate payload size (4 chars/token heuristic). If the estimate exceeds 750K characters, a warning is logged. This catches overflow between autocompact triggers and the actual call, a gap where large tool results can silently push context past limits.

Skill Listing Strip on Compaction

The stripReinjectedAttachments() function was gated behind a feature flag, meaning skill listing messages (~4K tokens) were fed to the summarizer during compaction. Wasting both the summarizer's context and the output tokens on summarizing a static list. Ungated.

Bash Permission Batched Parallelism

Bash command permission checking runs a chain of tree-sitter parses + validators for each subcommand. Stock code: sequential for...of over up to 50 subcommands. My code: parallel batches of 10 with event loop yields between batches. Prevents CPU starvation.

System Prompt Deduplication

Removed ~400 tokens of near-duplicate content (redundant preamble, repeated "be concise" instructions across sections).

The Skills System

Skills are slash commands that inject specialized prompts into the conversation context. They are registered at startup and activated on demand (zero cost until invoked).

Each skill provides a name, description, usage heuristic, and a prompt generator function.

21 Registered Skills

Category Skills
Always Available /update-config, /keybindings-help, /verify, /debug, /lorem-ipsum, /skillify, /remember, /simplify, /batch, /stuck, /unleash
Custom /hack, /health, /morph, /dream
Feature-Gated /loop, /schedule, /claude-api, /claude-in-chrome, /hunter, /run-skill-generator

/hack launches 3 parallel security scanners: secrets detection, vulnerability scanning, and dependency/auth audit.

/dream is a generative brainstorming engine that spawns 3 parallel "dreamer" workers (Pragmatist, Visionary, Wildcard) and synthesizes a comparison table with a recommended hybrid approach. I have found this INCREDIBLY useful for synthesizing new ideas, typically something an AI agent is bad at.

/morph provides dynamic personality modification with 10 presets plus arbitrary custom instructions. Personality is much more than just a preference thing, a nice fine-tuned personality will bypass permissions more than a normal "unseasoned" personality.

/health runs self-diagnostics verifying personality constants, autonomous mode, skill registration integrity, and git status.

An additional 124 skill files exist on disk covering code analysis, security, testing, git history, documentation, and autonomous operation. They can be activated with a single register call.

Project CHIMERA: 11 Background Intelligence Systems

This is the real contribution. CHIMERA is a suite of 11 systems that run automatically during every session. They are not prompts or skills. They are background services that make the tool faster, more reliable, and self-improving over time.

Design Principles

  1. Never crash the host. Every system is wrapped in try/catch. Silent failure is acceptable; crashing the query loop is not.
  2. Zero model calls for Tier 1-2. The first 7 systems use pure TypeScript: hashing, pattern matching, filesystem watchers. No additional costs.
  3. Additive context, not modified behavior. Systems inject warnings and context as attachment messages. They inform; they don't constrain.
  4. Stateless within the query loop. All state is managed in module-level singletons, never mutating the message array directly.

Loop Detector

Problem: Coding tools frequently try the same failing approach 3-4 times before changing strategy. Each retry burns a full round-trip ($0.03-0.10) and 10-30 seconds.

Solution: Track tool call signatures (tool name + SHA-256 hash of input) in a sliding window of 20. Three detection modes:

  1. Exact repeat: same tool + same input hash appears 3+ times
  2. A-B oscillation: alternating pattern detected in last 6 actions
  3. Same-tool hammering: one tool called 5+ times in 8 actions with 3+ failures

When detected, inject a circuit-breaker message: "You're in a loop. Here's what you tried. Try a different approach."

Error Journal

Problem: After context compaction, the tool loses visibility into errors from earlier in the session. It then repeats the same mistakes.

Solution: Session-scoped error log that records every failed tool execution with tool name, human-readable input summary, error message (first 500 chars), and turn index. Before each tool call of the same type, the last 3 relevant errors are injected as context. Survives compaction because it lives outside the message array.

Dead Store Elimination

Problem: Conversations accumulate massive tool outputs (file contents, grep results) that are read once and never referenced again. These consume 30-50% of the context window.

Solution: Treat the conversation as a dependency graph. For each tool result message, check if ANY subsequent assistant message contains overlapping content (sampled substring matching). If not, replace with a tombstone: [N tokens elided, unreferenced tool output].

This is the same sort of optimization that makes compilers fast.

Scar Tissue

Problem: Each session starts from zero. No memory of past failures in this project.

Solution: Persistent failure memory stored at ~/.claude/scars/. When a tool fails, extract a fingerprint of (toolName, errorClass, filePattern). If a matching scar exists, increment its count. Features:

  • Deduplication via fingerprinting
  • Decay (count halves every 30 days, pruned below 0.5)
  • Resolution tracking (when a fix works, it's recorded)
  • Injection threshold (only scars hit 2+ times are injected)
  • Project-scoped + global scars

File Watcher

Problem: The tool reads a file at turn 5, makes decisions at turn 15 based on that read. If the user edited the file in their IDE at turn 10, the tool is working with stale content. This causes phantom bugs, wrong edits, and confusion.

Solution: After every successful file read, register an fs.watch() listener. If the file changes externally, add it to a stale set. Before each call, check the stale set and inject a warning.

Constraints: max 50 concurrent watchers (LRU eviction), persistent: false + unref() (watchers never prevent process exit), one-shot warnings (don't spam the same stale file).

Immune Memory

Problem: Common errors (EACCES, MODULE_NOT_FOUND, node-gyp failures) have known fixes that work across projects. But the tool re-discovers these fixes from scratch every time.

Solution: Global antibody database at ~/.claude/immune-memory.json. Error signatures are normalized (paths become <PATH>, versions become <VERSION>, hashes become <HASH>) to create reusable regex patterns.

Confidence model: successRate = successes / encounters. Only antibodies with 60%+ success rate AND 2+ encounters are injected.

Loadout System

Problem: All 21 registered skills and their descriptions consume system prompt space regardless of relevance. When doing frontend work, you don't need /hack descriptions.

Solution: On first user message, detect the task domain via keyword scoring. Load a "loadout" with relevant skill subset, prioritized worker types, and domain-specific system prompt addon. 8 loadouts defined: Frontend, Backend, Security, DevOps, Data, Greenfield, Refactor, Testing. Zero model calls. Pure string matching.

Phantom Indexer

Problem: Every session, the tool re-discovers the codebase structure through grep/glob. It has no persistent understanding of file relationships or entry points.

Solution: Persistent incremental codebase graph at .claude/phantom/index.json. Contains:

  • File entries (one-line summary, exports, imports, complexity rating, line count, tags)
  • Dependency graph (edges from import statements)
  • Symbol table (exported functions, classes, types with file locations)

Incremental rebuild using git diff between the last indexed ref and HEAD. Only re-indexes changed files. Static analysis for TS/JS extracts exports and imports via regex (no AST parsing needed, fast and dependency-free).

Hydra Mode

Problem: Subagents are isolated workers. The main process is the bottleneck. Complex tasks could be parallelized with proper coordination.

Solution: DAG-based self-orchestrating worker swarm:

USER REQUEST -> PLANNER -> DAG -> EXECUTOR -> INTEGRATOR

  Scout -------> Architect --+--> Coder 1 --+--> Integrator
                             +--> Coder 2 --+

Nodes run when all dependencies are satisfied. Each node operates in an isolated git worktree. Failed nodes cascade-skip all dependents. The integrator merges all changes and runs tests.

Dreamweaver

Problem: Codebase maintenance (fixing TODOs, adding tests, removing dead code) is important but never urgent enough to do manually.

Solution: Autonomous overnight improvement engine. User kicks it off and goes to sleep. Four phases:

  1. Survey (10% of time): scan for TODOs, type errors, missing tests, dead exports
  2. Plan (5%): prioritize by impact * confidence * safety, skip items below 0.3
  3. Execute (75%): each item in its own worktree branch, commit only if tests pass
  4. Report (10%): morning briefing saved to .claude/dreamweaver-report.md

Safety guarantees: main branch is NEVER modified. Failed changes are reverted. Every commit requires passing tests.

Ouroboros

Problem: Skill prompts are static. Nobody knows which phrasing produces better results.

Solution: Self-evolving prompt A/B testing with ELO ratings.

  1. Each skill prompt has a "champion" variant (ELO 1200 baseline)
  2. 10% of invocations trigger an experiment: generate a mutation
  3. Run both variants on the same task, compare outputs
  4. Winner gets ELO boost, loser gets penalty (K-factor 32)
  5. After 50+ trials, if mutation exceeds champion by 50+ ELO, auto-promote

Mutation strategies (randomly selected): make instructions more specific, add explicit constraints preventing failure modes, restructure for better information hierarchy, add concrete output examples, remove redundant instructions, add "do NOT" constraints.

Over hundreds of invocations, prompts evolve toward maximum effectiveness through selection pressure.

Integration: 3 Hook Points

All 11 CHIMERA systems are wired into the existing codebase through exactly 3 hook points:

After Tool Execution (+5 lines)

afterToolExecution(tool.name, processedInput, false)
// In the catch block:
afterToolExecution(tool.name, processedInput, true, errorMsg)

This single call feeds: Loop Detector, Error Journal, Scar Tissue, Immune Memory, and File Watcher.

Before Each Call (+12 lines)

const chimeraInjections = beforeApiCall(turnCount)
if (chimeraInjections.length > 0) {
  messagesForQuery.push(createAttachmentMessage({
    type: 'system-reminder',
    message: chimeraInjections.join('\n\n'),
  }))
}

Collects warnings from Loop Detector, File Watcher, Scar Tissue, Loadout System, and Phantom Indexer.

Session Lifecycle (+8 lines)

chimera.onSessionStart(getProjectRoot(), getSessionId())
registerCleanup(async () => { chimera.onSessionEnd() })

The bridge module wraps all 11 systems. Every function catches its own errors. CHIMERA can NEVER crash the host. The query loop continues unaffected even if every system fails simultaneously.

Token Economics

The Systems That Pay for Themselves

System Mechanism Estimated Savings
Loop Detector Prevents 2-4 wasted retries 500-2000 tokens/loop
Error Journal Prevents repeated mistakes 300-1000 tokens/incident
Dead Store Elimination Removes unreferenced outputs 30-50% of context
File Watcher Prevents stale-data cascades 1000-5000 tokens/incident
Loadout System Removes irrelevant skill descriptions 500 tokens/session
Net effect 20-40% fewer tokens per session

Negligible Cost Additions

System Cost
Scar Tissue ~200 tokens injected early in session
Immune Memory ~100 tokens per antibody match
Phantom Indexer ~300 tokens of graph context
Ouroboros ~$0.001/experiment (10% invocation rate)
Hydra Mode User-triggered, explicit cost
Dreamweaver User-triggered, explicit cost

The first 7 systems save more tokens than they consume. The last 4 are user-triggered.

Lessons Learned

1. Most tokens are wasted on repetition, not reasoning

The Loop Detector and Error Journal target what is empirically the #1 source of token waste: trying the same failing approach multiple times. This is not the model's fault, tt's a context management failure. The tool just cannot see its own recent history after compaction.

2. Cross-session memory is dramatically underutilized

Every coding tool treats each session as a blank slate. Scar Tissue and Immune Memory demonstrate that even simple key-value persistence (error to fix) creates compound returns. The tool gets measurably better with every project it touches.

3. Compiler optimization theory applies to conversations

Dead Store Elimination proves that conversation histories have the same properties as compiler IR: most intermediate values are consumed once and never referenced again. The same optimization passes that make code fast make conversations efficient.

4. Personality is architecture, not decoration

The Position Zero injection pattern demonstrates that identity is a function of context ordering, not content alone. The same personality text at position 0 vs position 50 in the system prompt produces dramatically different behavioral adherence.

5. Self-modification is the ultimate capability

A tool that can edit its own source code is not just powerful. It's convergently self-improving. The system trends toward its own goals over time.

Total new code: ~2,476 lines across 18 files.

Most of the ideas behind this are not necessarily novel, but combined, they have an incredibly noticeable impact on the quality. I wouldn't be surprised if Claude ended up implementing many of these features in the future, as many of them were taken from their own internal roadmap. Right now, the code is closed source but if you are interested in my (or Khlawde's) specific approach, or want the code, feel free to reach out to me. I'd also love recommendations for any additions to this as I want to make it the true "superagent".

Clay

← All posts