Getting Started

Install once. Never think about it again.

Install

Run the installer from any terminal. It registers CodeCondense as a Claude Code plugin globally — all projects on this machine benefit immediately.

npx @codecondense/install

Alternatively, install via the Claude Code plugin system directly:

claude plugin add LCBO/codecondense_claude_plugin

Verify

Open a Claude Code session in any directory and run the status command:

/slim-status

You'll see your plan, version, trial usage, and which tools are active. If you see Slim active: true you're good.

Start coding

That's it. CodeCondense transparently intercepts Claude's tool calls and replaces them with optimised equivalents. You don't change prompts, workflows, or habits — costs just drop.

/slim-savings

Link your account (optional)

Generate an API key in your dashboard, then run:

/slim-login cc_your_key_here

Linking lifts free-plan call limits and enables cross-machine savings tracking in your dashboard.

How It Works

A transparent optimization layer inside Claude Code.

CodeCondense registers as an MCP (Model Context Protocol) server that Claude Code calls automatically. It exposes replacement tools under the mcp__slim__ namespace. When Claude would normally call Read five times, the plugin intercepts that pattern and issues a single mcp__slim__Investigate instead.

The replacement layer

Each CodeCondense tool is a drop-in replacement for one or more native Claude Code tools, but batches work that would otherwise require multiple round-trips:

What runs where

Everything runs on your machine inside the Claude Code process. No code is uploaded. No prompts are intercepted. The only outbound traffic is anonymous aggregate counters (tokens saved, calls eliminated) sent to CodeCondense servers — and even those can be disabled with telemetry: false.

Token savings explained

Claude Code sends the entire conversation context (all prior messages + tool results) with every tool call. When vanilla Claude makes 8 sequential tool calls to explore a codebase, it re-sends that growing context 8 times. A single Slim call sends it once. The token saving compounds: more calls = more re-sends = more wasted tokens. That's why savings percentages are often 70–90% even for small tasks.

Investigate

Symbol definition + usages + file map in one round-trip.

Investigate collapses the grep → read → find-definition loop into a single call. It queries three indexes simultaneously and returns a unified result:

• symbols — AST-indexed definitions: where the symbol is declared, file:line, and its type (function, class, method, interface…)
• matches — ripgrep usages: every location where the symbol is referenced across the codebase
• files — top files ranked by match density, each with a full AST symbol map (all definitions inside that file)

When to use it

Start every code exploration with Investigate instead of a Search→Read chain. Use Read or Search only for the specific file you've already identified.

// Find where "handleAuth" is defined and all callers
mcp__slim__Investigate({ query: "handleAuth" })

// Scope to a subtree
mcp__slim__Investigate({ query: "parseToken", path: "src/auth" })

// Scope to specific file types
mcp__slim__Investigate({ query: "Router", file_glob_patterns: ["**/*.ts"] })

Parameters

Smart Search

BM25 file discovery + grep + read in one call.

Smart Search combines file discovery, content grep, and file reading into a single call with configurable output modes. It replaces the common pattern of: find files → grep → read each file.

Output modes

// Read multiple files in one call (best pattern for exploration)
mcp__slim__Search({
  file_glob_patterns: ["src/components/**/*.tsx"],
  output_mode: "file_paths_with_content"
})

// Surgical grep with context
mcp__slim__Search({
  content_regex: "useEffect",
  file_glob_patterns: ["src/**/*.ts"],
  context_lines: 4
})

// AST summary of TypeScript files (no regex needed)
mcp__slim__Search({
  file_glob_patterns: ["src/lib/*.ts"],
  summary: true
})

Delta mode (re-reads)

When you need to re-read a file you've already read in this session, pass if_modified_since with the timestamp from the previous result. If the file hasn't changed, nothing is returned. If it has, only the diff is returned. This cuts re-read token cost by 80–95%.

// First read — save the timestamp from the result
const result = await mcp__slim__Search({ file: "src/auth.ts" });
const ts = result.timestamp;

// Later re-read — returns only changed lines
mcp__slim__Search({ file: "src/auth.ts", if_modified_since: ts })

Parameters

Batch Edit

All file edits in one atomic round-trip.

Batch Edit writes every change in a single call. Instead of Claude making N sequential Write calls (each re-sending the full conversation context), one Edit call carries all edits at once. A pre-write backup is created for every file touched.

Edit modes

// Create 3 files in one call
mcp__slim__Edit({
  edits: [
    { file: "src/auth.ts",    new_string: "export function login() { ... }" },
    { file: "src/db.ts",      new_string: "export const pool = ..." },
    { file: "src/index.ts",   new_string: "import './auth'; import './db';" },
  ]
})

// Search/replace in multiple files at once
mcp__slim__Edit({
  edits: [
    { file: "src/api.ts", old_string: "const BASE = 'http'", new_string: "const BASE = 'https'" },
    { file: "src/config.ts", old_string: "port: 80", new_string: "port: 443" },
  ]
})

Parameters (per edit)

Session Memory

Persistent, decay-scored knowledge that survives across sessions.

Session Memory gives Claude a long-term memory store. Information indexed in one session can be recalled in future sessions without re-reading files or re-explaining context. Entries decay over time so stale facts fade naturally — recent memories score higher.

How decay works

Every memory entry has a relevance score. Each day that passes, the score is multiplied by the decay rate (default: 0.95). A memory written today scores 1.0. After a week it scores 0.698. After a month, 0.215. This means actively used memories stay prominent while forgotten details fade — no manual cleanup needed.

score_today = original_score × (decay_rate ^ days_since_written)
// With default decay_rate = 0.95:
// Day 0:  1.000
// Day 7:  0.698
// Day 30: 0.215
// Day 90: 0.010 (effectively gone)

Memory types

Operations

// Save a memory
mcp__slim__Memory({ op: "index", name: "db-testing-rule",
  type: "feedback",
  body: "Never mock the DB. Integration tests must hit a real Postgres instance.",
  source: "2026-06-11 discussion" })

// Search memories semantically
mcp__slim__Memory({ op: "search", query: "database testing approach" })

// Get a specific memory by ID
mcp__slim__Memory({ op: "get", id: 42 })

// List all memories (by score, highest first)
mcp__slim__Memory({ op: "list", limit: 20 })

// Delete a memory
mcp__slim__Memory({ op: "forget", id: 42 })

// Stats: total entries, average score, decay rate
mcp__slim__Memory({ op: "stats" })

What to store vs. what not to store

Store: decisions and their reasons, preferences and constraints, team conventions, external system locations, recurring patterns in the user's workflow.

Don't store: code content or architecture (read the files instead), git history (use git log), anything in CLAUDE.md files, ephemeral task state from the current session.

Model Router

Route simple tasks to cheap models, complex ones to powerful models.

The Model Router is a local proxy (port 4891) that sits between Claude Code and Anthropic's API. It inspects each request and routes it to the most cost-effective model that can handle it.

Routing logic

The router classifies each request into one of three tiers:

Classification is based on: prompt length, number of tool calls in context, presence of keywords indicating complexity, and conversation depth. The routing decision is logged and visible via /slim-tail.

Enable the router

/slim-router start

Once started, Claude Code's API requests are proxied through localhost:4891. Set ANTHROPIC_BASE_URL=http://localhost:4891 in your environment or let the plugin configure it automatically.

Cost impact

In typical workloads, ~60% of requests qualify for Haiku (6× cheaper than Sonnet), ~30% for Sonnet, and ~10% for Opus. This yields an average 65–77% cost reduction on top of the token savings from the other tools.

CLI Reference

Slash commands available inside any Claude Code session.

Configuration

All settings live in ~/.slim/config.json

Edit the file directly or use the config flags. Changes take effect in the next Claude Code session.

{
  "apiKey": "",
  "telemetry": true,
  "memory": {
    "enabled": true,
    "decayRate": 0.95
  },
  "router": {
    "enabled": false,
    "port": 4891
  },
  "index": {
    "autoRebuild": true,
    "excludePatterns": ["node_modules", "dist", ".git", "__pycache__", ".next"]
  }
}

All options

FAQ