Repository files navigation

Check out Piebald

We've releasedPiebald, the ultimate agentic AI developer experience.
Download it and try it out for free!https://piebald.ai/

_{Scroll down for tweakcc. 👇}

tweakcc is a CLI tool that upgrades your Claude Code experience. Customize its system prompts, add custom themes, create toolsets, and personalize the UI. From the team behindPiebald.

With tweakcc, you can

• Customize all of Claude Code'ssystem prompts (NEW: also see all ofClaude Code's system prompts)
• Create customtoolsets that can be used in Claude Code with the new/toolset command
• Highlight custom patterns while you type in the CC input box with custom colors and styling, like howultrathink used to be rainbow-highlighted.
• Manually namesessions in Claude Code with/title my chat name or/rename (seeour blog post for implementation details)
• Createcustom themes with a graphical HSL/RGB color picker
• Add customthinking verbs that will show while Claude's working
• Create customthinking spinner animations with different speeds and phases
• Style theuser messages in the chat history beyond the default plain gray text
• Remove theASCII border from the input box
• Expandthinking blocks by default, so that you don't need to use the transcript (Ctrl+O) to see them
• Configure which Claudemodel eachsubagent (Plan, Explore, and general-purpose) uses
• Switch betweentable formats - Claude Code default, Unicode (┌─┬─┐), ASCII/markdown (|---|), Unicode without top/bottom borders.

tweakcc also

• Fixes a bug where thespinner animation is frozen if you have theCLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC environment variable set (#46)
• Allows you tochange the context limit (default: 200k tokens) used with models from custom Anthropic-compatible APIs with a new environment variable,CLAUDE_CODE_CONTEXT_LIMIT
• Adds theopusplan[1m] model alias, combining Opus for planning with Sonnet's 1M context for execution—reducing "context anxiety" (#108)
• Adds a message to Claude Code's startup banner indicating that you're running the patched version of CC (configurable)
• Speeds up Claude Code startup by~50% with non-blocking MCP connections and configurable parallel connection batch size (#406)
• Enables native multi-agent/swarm mode (TeammateTool, delegate mode, swarm spawning) by bypassing thetengu_brass_pebble Statsig flag.

tweakcc supports Claude Code installed onWindows, macOS, and Linux, bothnative/binary installations and those installed via npm, yarn, pnpm, bun, Homebrew/Linuxbrew, nvm, fnm, n, volta, nvs, and nodenv, as well as custom locations.

tweakcc supports Claude Code'snative installation, which is a large platform-specific native executable containing the same minified/compiled JavaScript code from npm, just packaged up in aBun binary. We support patching the native binary on macOS, Windows, and Linux, including ad-hoc signing on Apple Silicon, vianode-lief, our Node.js bindings forLIEF (Library to Instrument Executables).

While tweakcc has a large library of built-in patches, you can create custom patches by using tweakcc'sAPI. If you don't want to create an npm package, you can usetweakcc adhoc-patch, which applies a custom Node.js script to your default Claude Code installation. Becauseadhoc-patch supports running scripts from an HTTP URL, you can even host a script on a GitHub Gist or pastebin for easy distribution.

Run without installation:

$ npx tweakcc# Or use pnpm:$ pnpm dlx tweakcc

• How it works
• Remote config
• CLI Commands (unpack,repack,adhoc-patch)
• API
• System prompts
• Toolsets
• Features
  • System prompts
  • Themes
  • Thinking verbs customization
  • Thinking indicator customizations
  • Context limit
  • LSP support
  • Hide "ctrl-g to edit prompt in <editor>"
  • Hide the startup banner
  • Hide the startup "Clawd" logo
  • Increase the max size in tokens for files read viaRead
  • Remove the border from the message input box
  • Add all models to/model
  • tweakcc patches applied indicator
  • Show more items in select menus
  • Subagent models
  • Suppression of1→ prefixes fromRead output
  • Suppress/rate-limit-options from being injected
  • Swarm mode
  • Session memory
  • /remember skill
  • Toolsets
  • User message display customization
  • Token indicator display
  • Add support for dangerously bypassing permissions in sudo
  • Input pattern highlighters
  • Opus Plan 1M mode
  • MCP startup optimization
  • Table format
  • Swarm mode (native multi-agent)
  • Token count rounding
  • Statusline update customization
  • AGENTS.md support (with video)
  • Auto-accept plan mode
  • Suppress native installer warning
  • Scroll escape sequence filter
  • Missing documentation for above features coming soon
• Configuration directory
• Building from source
• Troubleshooting
• FAQ
• Contributing
• Related projects
• License

tweakcc works by patching Claude Code's minifiedcli.js file, reading customizations from~/.tweakcc/config.json. For npm-based installationscli.js is modified directly, but for native installations it's extracted from the binary usingnode-lief, patched, and then the binary is repacked. When you update your Claude Code installation, your customizations will be overwritten, but they're remembered in your configuration file, so they can be reapplied by just runningnpx tweakcc --apply.

tweakcc is verified to work with Claude Code2.1.32. In newer or earlier versions various patches might not work. However, if we have thesystem prompts for your version then system prompt patching is guaranteed to work with that version, even if it's significantly different from the verified CC version—the version number stated above is only relevant for the non-system-prompt patches. We get the latest system prompts within minutes of each new CC release, so unless you're using a CC version older than 2.0.14, your version is supported.

You can also create custom patches using tweakcc without having to fork it or open a PR.tweakcc adhoc-patch supports using custom scripts that work with native and npm-based installs and that automatically detect your Claude Code installation.

While tweakcc usually works by applying customizations from your local~/.tweakcc/config.json, you can optionally pass the--config-url <http URL> flag when you usetweakcc --apply to have tweakcc fetch config from a remote URL and apply it to your local Claude Code installation. This is useful for testing someone else's config when shared via a Gist or pastebin, for example.

Example:

npx tweakcc@latest --apply --config-url https://gist.githubusercontent.com/bl-ue/27323f9bfd4c18aaab51cad11c1148dc/raw/b24b5fe08874ce50f4be6c093d9589d184f91a70/config.json

Your local config willnot be overwritten; the remote config will be copied into yourconfig.json underremoteConfig.settings.

In addition to the interactive TUI (npx tweakcc) and the--apply flag, tweakcc provides three subcommands for advanced use:unpack,repack, andadhoc-patch.

npx tweakcc unpack<output-js-path> [binary-path]

npx tweakcc repack<input-js-path> [binary-path]

# Extract, edit, and repacknpx tweakcc unpack ./claude-code.js# ... make your edits to claude-code.js ...npx tweakcc repack ./claude-code.js

# Replace a fixed string with another string:npx tweakcc adhoc-patch --string'"Claude Code"''"My App"'# Replace all CSS-style RGB colors with bright red:npx tweakcc adhoc-patch --regex'rgb\(\d+,\d+,\d+\)''rgb(255,0,0)'# Erase all of CC's code and replace it with a simple console.log:npx tweakcc adhoc-patch --script$'return "(function(){console.log(\"Hi\")})()"'# Run a script from a local file:npx tweakcc adhoc-patch --script'@path/to/script.js'# Run a script from an HTTP URL (warning: this script makes everything in CC blue and changes "Claude Code" to "ABC Code CLI", which BREAKS CC):# Its contents are:##   js = js.replace(/Claude Code/g, "ABC Code CLI")#   js = js.replace(/rgb\(\d+,\d+,\d+\)/g, "rgb(0,128,255)")#   return js#npx tweakcc adhoc-patch --script'@https://gist.githubusercontent.com/bl-ue/2402a16b966176c994ea7bd5d11b0b09/raw/eeb0b78a6387f0e6a15182eeabd95f0e84e4ccd7/patch_cc.js'

Here's a demo ofadhoc-patch using a script from an HTTP URL (link to Gist):

tweakcc can be used as an npm dependency and provides an easy API that projects can use to patch Claude Code without worrying about where it's installed and whether it's native or npm-based. The functions are divided into 5 groups: config, installation, I/O, backup, and utilities.

/** * Returns the absolute path to tweakcc's config dir.  By default it's * `~/.tweakcc` but it also can use `~/.claude/tweakcc` and it also respects * `XDG_CONFIG_HOME`—see [Configuration Directory](#configuration-directory). */functiongetTweakccConfigDir():string;/** * Returns the absolute path to tweakcc's config file.  It's named `config.json` * and lives in the config dir as returned by `getTweakccConfigDir`. */functiongetTweakccConfigPath():string;/** * Returns the absolute path to the directory containing the user-editable * system prompt markdown files.  It's named `system-prompts/` and lives in the * config dir. */functiongetTweakccSystemPromptsDir():string;/** * Reads and returns the tweakcc config (as determined by `getTweakccConfigDir`). */functionreadTweakccConfig():Promise<TweakccConfig|null>;

>tweakcc.getTweakccConfigDir()'/home/user/.tweakcc'>tweakcc.getTweakccConfigPath()'/home/user/.tweakcc/config.json'>tweakcc.getTweakccSystemPromptsDir()'/home/user/.tweakcc/system-prompts'>awaittweakcc.readTweakccConfig(){ccVersion:'2.1.32',ccInstallationPath:'/home/user/.local/bin/claude',lastModified:'2026-02-05T21:18:48.551Z',changesApplied:true,settings:{ ...}}

/** * Finds all Claude Code installations on the machine via `$PATH` and hard-coded * search directories. */asyncfunctionfindAllInstallations():Promise<Installation[]>;/** * Prompts the user to select one of the specified Claude Code installations * interactively using the same UI tweakcc uses, powered by [Ink + React](https://github.com/vadimdemedes/ink). */asyncfunctionshowInteractiveInstallationPicker(candidates:Installation[]):Promise<Installation|null>;/** * Attempts to detect the user's preferred Claude Code installation.  Detection procedure: * 0. options.path * 1. Uses $TWEAKCC_CC_INSTALLATION_PATH if set. * 2. Uses ccInstallationPath in tweakcc config. * 3. Discovers installation from `claude` in PATH * 4. Looks in hard-coded search paths: *   a. If the search yields one installation, uses it *   b. If it yields multiple and options.interactive is true, display a picker *      via showInteractiveInstallationPicker(). */asyncfunctiontryDetectInstallation(options:DetectInstallationOptions={}):Promise<Installation>;

>constinsts=awaittweakcc.findAllInstallations()[{path:'C:\\Users\\user\\.local\\share\\claude\\versions\\2.0.60',version:'2.0.60',kind:'native'},{path:'C:\\Users\\user\\.local\\share\\claude\\versions\\2.0.76',version:'2.0.76',kind:'native'},{path:'C:\\Users\\user\\AppData\\Local\\Volta\\tools\\image\\packages\\@anthropic-ai\\claude-code\\node_modules\\@anthropic-ai\\claude-code\\cli.js',version:'2.1.32',kind:'npm'}]>awaittweakcc.tryDetectInstallation(){path:'C:\\Users\\user\\AppData\\Local\\Volta\\tools\\image\\packages\\@anthropic-ai\\claude-code\\node_modules\\@anthropic-ai\\claude-code\\cli.js',version:'2.1.32',kind:'npm'}>awaittweakcc.showInteractiveInstallationPicker(insts)NoclaudeexecutablewasfoundinPATH,butmultipleClaudeCodeinstallationswerefoundonthismachine.Pleaseselectone:❯ C:\Users\user\.local\share\claude\versions\2.0.60(native-binary,v2.0.60)  C:\Users\user\.local\share\claude\versions\2.0.76(native-binary,v2.0.76)  C:\Users\user\AppData\Local\Volta\tools\image\packages\@anthropic-ai\claude-code\node_modules\@anthropic-ai\claude-code\cli.js(npm-based,v2.1.32)YourchoicewillbesavedtoccInstallationPathin~\.tweakcc/config.json.Use↑↓arrowstonavigate,Entertoselect,Esctoquit

/** * Read Claude Code's JavaScript content. * * - npm installs: reads cli.js directly * - native installs: extracts embedded JS from binary */asyncfunctionreadContent(installation:Installation):Promise<string>;/** * Write modified JavaScript content back to Claude Code. * * - npm installs: writes to cli.js (handles permissions, hard links) * - native installs: repacks JS into binary */asyncfunctionwriteContent(installation:Installation,content:string):Promise<void>;

>constnative2076Inst={path:'C:\\Users\\user\\.local\\share\\claude\\versions\\2.0.76',kind:'native'};// Reading native content:>letcontent=awaittweakcc.readContent(native2076Inst);>content.length10639722// 10.6 MB>content.slice(4153122,4153122+236)"var be$=\"You are Claude Code, Anthropic's official CLI for Claude.\",UBD=\"You are Claude Code, Anthropic's official CLI for Claude, running within the Claude Agent SDK.\",GBD=\"You are a Claude agent, built on Anthropic's Claude Agent SDK.\""// Updating and re-reading native content:>content=content.replace(/ClaudeCode/g,'My App')>content=content.replace(/Anthropic(?:PBC)?/g,'My Corp')>awaittweakcc.writeContent(native2076Inst,content)undefined>(awaittweakcc.readContent(native2076Inst)).slice(4153122+16,4153122+172)"var be$=\"You are My App, My Corp's official CLI for Claude.\",UBD=\"You are My App, My Corp's official CLI for Claude, running within the Claude Agent SDK.\",GBD=\"You are a Claude agent, built on My Corp's Claude Agent SDK.\""

/** * Backup a file to a specified location, creating parent directories if needed. * Leaves the original file untouched. */asyncfunctionbackupFile(sourcePath:string,backupPath:string):Promise<void>;/** * Restore a file from a backup, breaking hard links, which are common with pnpm/bun * installations, and preserving execute permissions. */asyncfunctionrestoreBackup(backupPath:string,targetPath:string):Promise<void>;

// Make a backup of the original install:>constnative2076Inst={path:'C:\\Users\\user\\.local\\share\\claude\\versions\\2.0.76',kind:'native'};>constbackupPath=path.join(os.homedir(),".myapp",`cc-${native2076Inst.kind}-backup`);>awaittweakcc.backupFile(native2076Inst.path,backupPath);undefined>fs.statSync(backupPath).size234454688// <-- It was made successfully; 234.5 MB.// Now patch the original:>awaittweakcc.writeContent(native2076Inst,"(function(){console.log(\"Hi\")})");>(awaittweakcc.readContent(native2076Inst)).length31// <-- Original was successfully modified.// Restore the backup:>awaittweakcc.restoreBackup(backupPath,native2076Inst.path)>(awaittweakcc.readContent(native2076Inst)).length234454688// Original, unpatched size.

// Utilities to find various commonly-used variables in CC's code.// See the docs for `tweakcc adhoc-patch --script` above for more details.findChalkVar(fileContents:string):string|undefined;getModuleLoaderFunction(fileContents:string):string|undefined;getReactVar(fileContents:string):string|undefined;getRequireFuncName(fileContents:string):string|undefined;findTextComponent(fileContents:string):string|undefined;findBoxComponent(fileContents:string):string|undefined;/** * Clears the process-global caches that some of the above functions populate * to speed up subsequent repeated calls.  Use this when processing multiple CC * installs in one process. */clearCaches():void;/** * Debug function for showing diffs between old and new file contents using smart word-level diffing. * * Uses the `diff` library to compute word-level differences and displays them with * chalk-styled colors: green background for additions, red background for removals, and * dim text for unchanged portions. * * Only outputs when --verbose flag is set. * *@param oldFileContents - The original file content before modification *@param newFileContents - The modified file content after patching *@param injectedText - The text that was injected (used to calculate context window) *@param startIndex - The start index where the modification occurred *@param endIndex - The end index of the original content that was replaced *@param numContextChars - Number of context characters to show before and after diff. */exportconstshowDiff=(oldFileContents:string,newFileContents:string,injectedText:string,startIndex:number,endIndex:number,numContextChars:number=40):void;/** * Performs a global replace on a string, finding all matches first, then replacing * them in reverse order (to preserve indices), and calling showDiff for each replacement. * *@param content - The string to perform replacements on *@param pattern - The regex pattern to match (should have 'g' flag for multiple matches) *@param replacement - Either a string or a replacer function (same as String.replace) *@returns The modified string with all replacements applied * *@example * ```ts * const result = globalReplace( *   content, *   /throw Error\(`something`\);/g, *   '' * ); * ``` */exportconstglobalReplace=(content:string,pattern:RegExp,replacement:string|((substring:string, ...args:unknown[])=>string)):string;

constpattern=/function[$\w]+\(\)\{return[$\w]+\("my_feature_flag"/;constmatch=file.match(pattern)!;constinsertIndex=match.index+match[0].indexOf('{')+1;constinsertion='return true;';constnewFile=file.slice(0,insertIndex)+insertion+file.slice(insertIndex);showDiff(file,newFile,insertion,insertIndex,insertIndex);

newFile=globalReplace(newFile,/"ClaudeCode",/g,'"My App"');

tweakcc allows you to customize the various parts of Claude Code's system prompt, including

• the main system prompt and any conditional bits,
• descriptions for all 17 builtin tools likeBash,TodoWrite,Read, etc.,
• prompts for builtin Task/Plan/Explore subagents, and
• prompts for utilities such as conversation compaction, WebFetch summarization, Bash command analysis, CLAUDE.md/output style/statusline creation, and many more.

👉 SeeClaude Code System Prompts for a breakdown of all the system prompt parts, as well as a changelog and diffs for each CC version.

Because the system prompt isdynamically composed based on several factors,it's not one string that can be simply modified in a text editor. It's a bunch of smaller strings sprinkled throughout Claude Code's source code.

tweakcc's method for modifying the system prompts involves maintaining one markdown file for each individual portion of the prompt, resulting in a file for each tool description, each agent/utility prompt, and one for the main system prompt and a few more for various large notes inserted into other prompt parts.

When tweakcc starts up, it downloads a list of system prompt parts for your Claude Code installation from GitHub (thedata/prompts folder in the tweakcc repo). It then checks if each prompt part has a corresponding markdown file on disk, creating ones that don't exist and populating them with the default text for the version.

⭐To customize any part of the system prompt, simply edit the markdown files in~/.tweakcc/system-prompts (or$XDG_CONFIG_HOME/tweakcc/system-prompts) and then runnpx tweakcc --apply.

When your Claude Code installation is updated, tweakcc will automatically update all of your markdown files that correspond to parts of the system prompt that were changed in the new version, unless you've modified any of them. But if youdid modify ones that Anthropic has also modified, then tweakcc will leave the ones you modified unchanged, and rely on you to resolve the conflict.

To assist you with resolving the conflicts, tweakcc will generate an HTML file that shows on the left, the diff of the change you've made, and on the right, the diff of Anthropic's changes. That way you can recall at a glance what you've changed in the prompt, and easily see what's changed in the new prompt. Then you can modify the markdown file for the prompt, incorporate or ignore new changes as you see fit.

Screenshot of the HTML file:

This is a great idea, and we recommend it; in fact, we have one ourselveshere. It allows you to keep your modified prompt safe in GitHub or elsewhere, and you can also switch from one set of prompts to another via branches, for example. In the future we plan to integrate git repo management for the system prompt markdown files into tweakcc. For now you'll need to manually initialize a git repository in~/.tweakcc directory. tweakcc automatically generates a recommended.gitignore file in that directory (which you can modify if you'd like).

Toolsets are collections of built-in tools that Claude is allowed to call. Unlike Claude Code's builtin permission system, however, built-in tools that are not in the currently active toolset are not even sent to the model. As a result, Claude has no idea of tools that are not enabled in the current toolset (unless they happen to be mentioned in other parts of the system prompt), and it's not able to call them.

Toolsets can be helpful both for using Claude in different modes, e.g. a research mode where you might only includeWebFetch andWebSearch, and for reducing the size of your system prompt by trimming out tools you don't ever want Claude to call. The description of each tool call is placed in the system prompt (seehere), and if there are multiple tools you don't care about (likeSkill,SlashCommand,BashOutput, etc.), the accumulated size of their descriptions and parameters can bloat the context by several thousand tokens.

To create a toolset, runnpx tweakcc, go toToolsets, and hitn to create a new toolset. Set a name and enable/disable some tools, runtweakcc --apply to apply your customizations, and then runclaude. If you marked a toolset as the default in tweakcc, it will be automatically selected.

Customize the thinking verbs that appear while Claude is generating responses, along with the format string. You can change from the default"Thinking… " format to something more fun like"Claude is {verb}ing..." or anything else you prefer.

Here's a demo showing a custom thinking verb format in action:

To customize thinking verbs, you can use the tweakcc UI or edit~/.tweakcc/config.json manually.

Via the UI:

1. Runnpx tweakcc
2. Navigate to the"Thinking verbs" section
3. Use the tab key to switch betweenFormat andVerbs sections
4. Edit the format string: the{} placeholder will be replaced with a randomly selected verb
5. Add, edit, or remove verbs from the list
6. Apply changes when satisfied

Viaconfig.json:

In.settings.thinkingVerbs, configure theformat andverbs:

"thinkingVerbs": {"format":"{}…","verbs": ["Accomplishing","Baking","Cogitating","Fermenting","Moonwalking","Noodling"  ]}

Here's the schema:

{  format:string;// Format string, use {} as placeholder for the verb  verbs:string[];// Array of verbs (Claude randomly selects one)}

Examples of different formats:

• Default format:"{}… " → displays as"Thinking… "
• Custom format:"Claude is {verb}ing..." → displays as"Claude is Baking..."
• Custom format:"✻ {verb} (generating)" → displays as"✻ Baking (generating)"
• Custom format:"<{verb}> " → displays as"<Baking> "

Reset to defaults:

To reset to the default verbs and format, runnpx tweakcc, navigate toThinking verbs, and pressCtrl+R to restore defaults (which include 200+ fun verbs like "Beboppin'", "Fermenting", "Moonwalking", etc.).

Customize the thinking indicator (spinner) animation that appears alongside the thinking verb. You can change the animation phases, speed, and whether it reverses direction.

The thinking indicator consists of a sequence of characters that cycle through while Claude is thinking, displayed alongside the thinking verb (e.g.,Thinking· →Thinking✢ →Thinking✳ → etc.).

Viaconfig.json:

In.settings.thinkingStyle, configure the animation:

"thinkingStyle": {"updateInterval":120,"phases": ["·","✢","✳","✶","✻","✽"  ],"reverseMirror":true}

Here's the schema:

{  updateInterval:number;// Animation speed in milliseconds (lower = faster)  phases:string[];// Array of characters that cycle through  reverseMirror:boolean;// Whether to reverse the animation sequence}

Examples of different animations:

Speed customization:

• updateInterval: 60 → Very fast animation (60ms per phase)
• updateInterval: 120 → Default speed (120ms per phase)
• updateInterval: 250 → Slower animation (250ms per phase)

For a few weeks, when you typed the word "ultrathink" into the Claude Code input box, it would be highlighted rainbow. That's gone now, but the underlying highlighting infrastructure is still present in Claude Code today, and tweakcc lets you specify custom highlighters comprised of aregular expression,format string, andcolors & styling.

Here's a demo where every word is assigned a different color based on its first letter:

Here's one where various common patterns like environment variables, file paths, numbers, and markdown constructs are highlighted:

Finally, here's one showing how you can render extra characters that aren't really part of the prompt by customizing theformat string. The first line shows a copy of what I've actually got typed into the prompt, and in the prompt itself you can see thatcluade wasvisually (but notin reality) replaced withClaude Code, ..., etc.

To add some patterns, you can use the tweakcc UI or edit~/.tweakcc/config.json manually.

Via the UI:

Listing	Edit

Viaconfig.json:

In.settings.inputPatternHighlighters (an array), add a new object:

"inputPatternHighlighters": [...  {"name":"File path","regex":"(?:[a-zA-Z]:)?[/\\\\]?[a-zA-Z0-9._\\-]+(?:[/\\\\][a-zA-Z0-9._\\-]+)+","regexFlags":"g","format":"{MATCH}","styling": ["bold"    ],"foregroundColor":"rgb(71,194,10)","backgroundColor":null,"enabled":true  },]

Here's the schema for the object format:

{  name:string;// User-friendly name  regex:string;// Regex pattern (stored as string)  regexFlags:string;// Flags for the regex, must include 'g' for matchAll  format:string;// Format string, use {MATCH} as placeholder  styling:string[];// ['bold', 'italic', 'underline', 'strikethrough', 'inverse']  foregroundColor:string|null;// null = don't specify, otherwise rgb(r,g,b)  backgroundColor:string|null;// null = don't specify, otherwise rgb(r,g,b)  enabled:boolean;// Temporarily disable this pattern}

tweakcc adds support for a new model alias:opusplan[1m]. This combines the best of both worlds:

• Plan mode: UsesOpus 4.5 for complex reasoning and architecture decisions
• Execution mode: UsesSonnet 4.5 with 1M context for code generation

Claude Sonnet 4.5 is aware of its context window, so when it gets close to full, the model exhibitscontext anxiety, where it thinks there may not be enough context to complete the given task, so it takes shortcuts or leaves subtasks incomplete.

By using the 1M context model, Claude thinks it has plenty of room and doesn't skip things, and as long as you ensure you stay under 200k tokens you'll be charged the normal input/output rates even though you're using the 1M model. However, once you exceed 200k tokens when using the 1M model, you'll be automatically charged premium rates (2x for input tokens and 1.5x for output tokens)—seethe 1M context window docs.

After applying tweakcc patches, you can useopusplan[1m] like any other model alias:

# Via CLI flagclaude --model opusplan[1m]# Or set it permanently via /model command in Claude Code/model opusplan[1m]

If you use multiple MCP servers, Claude Code's startup can be slow—waiting 10-15+ seconds for all servers to connect before you can start typing.

tweakcc fixes this with two optimizations (based onthis blog post):

1. Non-blocking MCP connections (enabled by default): Start typing immediately while MCP servers connect in the background
2. Configurable batch size: Connect more servers in parallel (default: 3, configurable from 1-20)

Via the UI: Runnpx tweakcc, go toMisc, and adjust:

• Non-blocking MCP startup — Toggle on/off (default: on)
• MCP server batch size — Use ←/→ arrows to adjust (1-20)

Viaconfig.json:

{"settings": {"misc": {"mcpConnectionNonBlocking":true,"mcpServerBatchSize":8    }  }}

Recent Claude Code versions render tables using Unicode box-drawing characters. While these have a more elegant look compared to the traditional plain markdown table rendering, they take up more room due to the row dividers:

default — Original box-drawing with all row separators:

┌───────────┬───────────────────────────────┬───────┐│  Library  │            Purpose            │ Size  │├───────────┼───────────────────────────────┼───────┤│ React     │ UI components, virtual DOM    │ ~40kb │├───────────┼───────────────────────────────┼───────┤│ Vue       │ Progressive framework         │ ~34kb │├───────────┼───────────────────────────────┼───────┤│ Svelte    │ Compile-time framework        │ ~2kb  │└───────────┴───────────────────────────────┴───────┘

tweakcc provides three alternative formats:

ascii — ASCII/Markdown style using| and- (easy to copy-paste):

|  Library  |            Purpose            | Size  ||-----------|-------------------------------|-------|| React     | UI components, virtual DOM    | ~40kb || Vue       | Progressive framework         | ~34kb || Svelte    | Compile-time framework        | ~2kb  |

clean — Box-drawing without top/bottom borders or row separators:

│  Library  │            Purpose            │ Size  │├───────────┼───────────────────────────────┼───────┤│ React     │ UI components, virtual DOM    │ ~40kb ││ Vue       │ Progressive framework         │ ~34kb ││ Svelte    │ Compile-time framework        │ ~2kb  │

clean-top-bottom — Box-drawing with top/bottom borders but no row separators:

┌───────────┬───────────────────────────────┬───────┐│  Library  │            Purpose            │ Size  │├───────────┼───────────────────────────────┼───────┤│ React     │ UI components, virtual DOM    │ ~40kb ││ Vue       │ Progressive framework         │ ~34kb ││ Svelte    │ Compile-time framework        │ ~2kb  │└───────────┴───────────────────────────────┴───────┘

Via the UI: Runnpx tweakcc, go toMisc, and cycle through theTable format options with spacebar. Then apply your customizations.

Viaconfig.json:

{"settings": {"misc": {"tableFormat":"ascii"    }  }}

Valid values are"default","ascii","clean", and"clean-top-bottom".

Claude Code 2.1.16+ includes native multi-agent features that are gated behind thetengu_brass_pebble Statsig flag. tweakcc patches this gate to enable these features for everyone.

Features unlocked:

Enable/disable

Via the UI: Runnpx tweakcc, go toMisc, and check/uncheckEnable swarm mode (native multi-agent). ThenApply customizations.

Viaconfig.json:

{"settings": {"misc": {"enableSwarmMode":true    }  }}

In the generation status, where the thinking verb is displayed, e.g.✻ Improvising… (35s · ↓ 279 tokens), the token count estimate will increase very rapidly at times. While it's helpful to know that the connection isn't stalled, such frequent UI updates can cause rendering issues in slow terminals, and if Claude Code is being run from a network, frequent updates can clog the network.

tweakcc can automatically round the token counters to the nearest multiple of a custom base number. For example, here are two demo clips showing the token count rounded to multiples of 50, and multiples of 1000:

Description	GIF
Multiples of 50
Multiples of 1000

Configuration via UI: Go toMisc → Token count rounding towards the bottom.

Configuration viaconfig.json: While the tweakcc UI only allows common values like 10, 25, 500, 1000, etc., you can use any integer value for the setting itself inconfig.json. Open~/.tweakcc/config.json and set thesettings.misc.tokenCountRounding field to your desired rounding base:

{"settings": {"misc": {"tokenCountRounding":123    }  }}

Now token counts will be rounded to the nearest multiple of 123, e.g. 123, 246, 369, etc.

Claude Code's statusline feature operates by running a specific command (e.g. a shell script) whenever the conversation history changes (i.e., a message is added), capturing the command's output—including ANSI escape codes for coloring—and rendering it in Claude Code under the input box.

It's neat functionality but the updates occur at what appear to be sporadic intervals. According tothe docs,"Updates run at most every 300 ms," but this is inaccurate—technically, updates arequeued for 300 milliseconds, meaning an update is triggered each time the chat history is updated, but is then delayed before execution for 300ms.

In the majority of cases, this behavior is fine. However, if you have a specialized use case, you may need updates to be throttled at 300ms like the documentation states, or even have updates automatically triggered at a specific interval.

tweakcc can patch Claude Code to correct this erratic queuing behavior, making it properly throttle updates at a customizable interval. It can also pace the updating, making it be performed at a regular interval, independent of changes to the chat history.

Here are two demos showing 1) updates triggered every 150ms, and 2) updates triggered by history updates, throttled at 1s. Theupdate = X is a custom statusline, whereX increments each time the statusline is re-rendered.

150ms interval	1000ms throttling

Configuration via UI: Go toMisc → Statusline throttle

Configuration viaconfig.json: While the tweakcc UI only allows increments of 50ms for the statusline update interval, you can use any integer value for it by editingconfig.json. Open~/.tweakcc/config.json and set thesettings.misc.statuslineThrottleMs field to your desired interval, and setsettings.misc.statuslineUseFixedInterval totrue for a fixed-pace interval orfalse for throttling.

{"settings": {"misc": {"statuslineThrottleMs":500,"statuslineUseFixedInterval":false    }  }}

_{Supported Claude Code versions: 1.0.24 (and likely older) to 2.1.32+.}

Claude Code is the only coding agent that doesn't supportAGENTS.md; it only supportsCLAUDE.md andCLAUDE.local.md. (This issue has over 2200 upvotes.) tweakcc automatically patches Claude Code to fall back toAGENTS.md and several others whenCLAUDE.md doesn't exist.

The patch happens automatically, with a default set ofAGENTS.md,GEMINI.md,CRUSH.md,QWEN.md,IFLOW.md,WARP.md, andcopilot-instructions.md—you don't need to configure it specifically. However, if you'd like to support other file names, you can do so easily:

Via UI: Runnpx tweakcc@latest and go toCLAUDE.md alternate names. Usee to edit a name,d to delete one,n to add a new one,u/j to move one up/down, andctrl + r to reset to the default list mentioned above:

Viaconfig.json: To configure the list of alternateCLAUDE.md names headlessly, setsettings.claudeMdAltNames to a list of your desired names, in descending order of priority:

{"settings": {"claudeMdAltNames": ["AGENTS.md","context.md"]  }}

Note thatCLAUDE.md is always used above all alternatives when it's available, so it's not required to include it in the list.

Here's a demo video ofAGENTS.md working:

⚠️Warning: This feature disables a security check. Only enable it if you understand the implications.

By default, Claude Code prevents the use of--dangerously-skip-permissions when running undersudo to avoid accidental system-wide permission bypasses. This patch removes that restriction.

Why you might need this: Some system administration tasks or automated deployment scripts may require running Claude Code with elevated privileges while also bypassing permission checks. For example, when deploying to restricted directories or modifying system configuration files.

Security implications: When enabled, you can run Claude Code with sudo and bypass permission checks, potentially allowing Claude to perform system-level operations without prompts. Use extreme caution.

Via the UI: Runnpx tweakcc, go toMisc, and toggleAllow bypass permissions in sudo.

Viaconfig.json:

{"settings": {"misc": {"allowBypassPermissionsInSudo":true    }  }}

Usage:

sudo claude --dangerously-skip-permissions

_{Supported Claude Code versions: 2.1.22 to 2.1.32+.}

When Claude finishes writing a plan and callsExitPlanMode, you're normally shown a "Ready to code?" dialog with options to approve or continue editing. This patch automatically selects "Yes, clear context and auto-accept edits" without requiring user interaction.

Via UI: Runnpx tweakcc@latest and navigate toMiscellaneous Settings. Scroll down to findAuto-accept plan mode and press space to enable it.

Viaconfig.json: Setsettings.misc.autoAcceptPlanMode totrue:

{"settings": {"misc": {"autoAcceptPlanMode":true    }  }}

When Claude Code detects that you've installed via npm, it warns you to use the native installer.Via the UI: Runnpx tweakcc, go toMisc, and toggleSuppress native installer warning.

Viaconfig.json:

{"settings": {"misc": {"suppressNativeInstallerWarning":true    }  }}

Some terminals may experience unwanted scrolling behavior caused by certain cursor positioning escape sequences (e.g.,\x1b[H and\x1b[A). This patch filters out these problematic escape sequences from Claude Code's output to prevent scrolling issues.

Via the UI: Runnpx tweakcc, go toMisc, and toggleFilter scroll escape sequences.

Viaconfig.json:

{"settings": {"misc": {"filterScrollEscapeSequences":true    }  }}

tweakcc stores its configuration files in one of the following locations, in order of priority:

1. TWEAKCC_CONFIG_DIR environment variable if set, or
2. ~/.tweakcc/ if it exists, or
3. ~/.claude/tweakcc if it exists, or
4. $XDG_CONFIG_HOME/tweakcc if theXDG_CONFIG_HOME environment variable is set.

If none of the above exist,~/.tweakcc will be created and used. If you version control~/.claude for Claude Code configuration and want your tweakcc config and system prompts there too, then manually create the directory first, or move your existing~/.tweakcc directory there:

# For new usersmkdir -p~/.claude/tweakcc# For existing usersmv~/.tweakcc~/.claude/tweakcc

You can use tweakcc by runningnpx tweakcc, ornpm install -g tweakcc and thentweakcc. Or build and run it locally:

git clone https://github.com/Piebald-AI/tweakcc.gitcd tweakccpnpm ipnpm buildnode dist/index.mjs

tweakcc stores a backup of your Claude Codecli.js/binary for when you want to revert your customizations and for reapplying patches. Before it applies your customizations, it restores the originalcli.js/binary so that it can start from a clean slate. Sometimes things can get confused and yourclaude can be corrupted.

In particular, you may run into a situation where you have a tweakcc-patched (or maybe a prettier-formatted)claude but no tweakcc backup. And then it makes a backup of that modifiedclaude. If you then try to reinstall Claude Code and apply your customizations, tweakcc will restore its backup of the oldmodifiedclaude.

To break out of this loop you can install a different version of Claude Code, which will cause tweakcc to discard its existing backup and take a fresh backup of the newclaude file. Or you can simply delete tweakcc's backup file (located at~/.tweakcc/cli.backup.js or~/.tweakcc/native-binary.backup). If you do deletecli.backup.js ornative-binary.backup, make sure you reinstall Claude Codebefore you run tweakcc again, because if yourclaude is still the modified version, it will get into the same loop again.

Contributions are welcome! Whether you're fixing a bug, adding a new feature, improving documentation, or adding tests, we appreciate your help.

For detailed guidelines on development setup, code style, testing, and submitting pull requests, see theCONTRIBUTING.md file.

Quick Start:

1. Fork the repository and create a new branch
2. Make your changes following the code style guidelines
3. Run tests and linting:pnpm test && pnpm lint
4. Submit a pull request with a clear description

• cc-mirror - Create multiple isolated Claude Code variants with custom providers (Z.ai, MiniMax, OpenRouter, LiteLLM). Uses tweakcc to customize system prompts, themes, thinking styles, and toolsets.

Other tools for customizing Claude Code or adding functionality to it:

• clotilde - Wrapper for Claude Code that adds powerful manual session naming, resuming, forking, and incognito (ephemeral) session management to Claude Code.
• ccstatusline - Highly customizable status line formatter for Claude Code CLI that displays model info, git branch, token usage, and other metrics in your terminal.
• claude-powerline - Vim-style powerline statusline for Claude Code with real-time usage tracking, git integration, and custom themes.
• CCometixLine - A high-performance Claude Code statusline tool written in Rust with Git integration, usage tracking, interactive TUI configuration, and Claude Code enhancement utilities.

Forks:

• tweakgc-cli - CLI tool to extend the GitHub Copilot CLI to accept more selectable models.

MIT

Copyright © 2026Piebald LLC.