Chisle

<p align="center"> <img src="assets/logo.png" width="120" alt="Chisle"> </p> <h1 align="center">Chisle</h1> <p align="center"> <em>Your AI talks less, builds less, reads less, and says more. Like a senior dev who bills by the syllable.</em> </p> <p align="center"> <em>The only tool in this class that publishes the runs where it lost.</em> </p> <p align="center"> <a href="https://www.npmjs.com/package/chisle"><img src="https://img.shields.io/npm/v/chisle?style=flat-square&color=d78a3c" alt="npm version"></a> <img src="https://img.shields.io/badge/works%20with-11%20agents-d78a3c?style=flat-square" alt="Works with 11 agents"> <a href="https://github.com/JayPokale/Chisle/actions/workflows/test.yml"><img src="https://img.shields.io/github/actions/workflow/status/JayPokale/Chisle/test.yml?style=flat-square&label=CI" alt="CI"></a> <img src="https://img.shields.io/badge/deps-0-2da44e?style=flat-square" alt="Zero deps"> <img src="https://img.shields.io/badge/license-MIT-d78a3c?style=flat-square" alt="MIT"> <a href="https://github.com/JayPokale/Chisle/stargazers"><img src="https://img.shields.io/github/stars/JayPokale/Chisle?style=social" alt="Star Chisle on GitHub"></a> </p> <p align="center"> <strong>44% of a bare model's output tokens on coding prompts &middot; 11 agents &middot; zero dependencies &middot; one command</strong> </p> <p align="center"> <a href="https://chisle.jaypokale.me"><strong>chisle.jaypokale.me</strong></a> is the site version of this README, with fewer words </p>

---

"Add debounce to a search input that currently fires an API call on every keystroke." Same model, same prompt, one difference: the injected ruleset. Both answers below are the verbatim committed output from benchmarks/results/raw/:

<table> <tr><th align="left" width="50%">bare agent: 142 lines, 1506 tokens</th><th align="left" width="50%">Chisle: 35 lines, 602 tokens</th></tr> <tr valign="top"><td>

Opens with "Let me show you the most common approaches", then ships a reusable generic useDebounce<T> hook in its own file…

// useDebounce.ts
export function useDebounce<T>(
  value: T, delay: number
): T {
  const [debouncedValue, setDebouncedValue]
    = useState<T>(value);
  useEffect(() => { /* … */ }, [value, delay]);
  return debouncedValue;
}

…then Option 2 and Option 3, a comparison table, and a caveats section.

</td><td>

Asks which framework, then answers the question that was actually asked: setTimeout in the effect you already have, no new file, no generic:

useEffect(() => {
  const timer = setTimeout(async () => {
    if (query.trim()) { /* fetch */ }
  }, 300);
  return () => clearTimeout(timer);
}, [query]);

Then two lines on why it works, and "use lodash.debounce if already installed."

</td></tr> </table>

Not golfed, boring. Same behaviour, one less abstraction, no second file, and it names the dependency you might already have instead of reinventing it.

Most efficiency tools compress one thing. Chisle compresses three:

| axis | what | how | |---|---|---| | Output: prose | filler, hedging, manufactured structure | zero-fluff ruleset, injected per session | | Output: code | speculative abstractions, unrequested boilerplate | YAGNI efficiency ladder | | Input: context | oversized tool output flooding the window | Claude PostToolUse / Pi tool_result: scrub, elide, dedup, plus prevention rules |

Where each one attaches to a session:

flowchart LR
    subgraph S["Session start"]
        H1["Ruleset injection<br/>once per active session"]
    end
    subgraph T["Every turn"]
        H2["Mode tracking<br/>Claude + Pi"]
    end
    subgraph L["Every tool call"]
        H3["PostToolUse / tool_result<br/>scrub → elide → dedup"]
    end

    H1 --> M(["Model"])
    H2 --> M
    M -->|writes| O["Output:<br/>terser prose,<br/>YAGNI-first code"]
    M -->|calls a tool| TOOL[["Bash / grep / web / extension tools"]]
    TOOL -->|raw output| H3
    H3 -->|"compressed, rebuilt into<br/>the tool's own shape"| M

    RE["Read / Edit / Write"] -.->|"never touched,<br/>exact bytes feed later edits"| M

    style M fill:#1f2937,stroke:#d78a3c,color:#e6edf3
    style O fill:#14532d,stroke:#2da44e,color:#e6edf3
    style H3 fill:#1f2937,stroke:#2da44e,color:#e6edf3
    style RE fill:#3f1d1d,stroke:#cf3b3b,color:#e6edf3

The loop on the right is the input axis: tool output is billed again on every later request in the session, so shrinking it once pays repeatedly. Read, Edit, and Write are deliberately outside it.

<p align="center"> <img src="assets/thumbnail.png" width="820" alt="Chisle: less tokens, same results. Four parts: output compressor (compress noisy tool outputs), context diet (read only what's actually relevant), terse persona (short, focused, YAGNI-first), YAGNI ladder (do less, reuse more, build only when needed)."> </p>

Every "be concise" tool has a worst day, the day it makes the model write more than no tool at all. Across 20 measured tasks over two suites, the specialists had that day 6 and 8 times, blowing up to 424% of the baseline. Chisle had it once, capped at 173%, and that one failure was root-caused, fixed in the ruleset, and re-validated live at 93%, with the whole investigation committed to the repo. Think of it as downside insurance for your token bill: not always the single cheapest answer, always the smallest worst case, from the only tool in this class that publishes its own failures. Why not caveman or ponytail? →

---

Install

One command. Auto-detects your agents (Claude Code, Pi, Cursor, Windsurf, Cline, Kiro, Codex, Gemini, Copilot, OpenCode, Hermes) and wires each one. --uninstall puts everything back.

npx chisle

# or via curl
curl -fsSL https://raw.githubusercontent.com/JayPokale/Chisle/main/install.sh | bash

# Windows
irm https://raw.githubusercontent.com/JayPokale/Chisle/main/install.ps1 | iex

Preview first with npx chisle --dry-run, scope with --only claude or --only pi, see everything with npx chisle --help. Remove with npx chisle --uninstall.

Requirements: Node ≥18 (installer / npx) · Claude Code or Pi for /chisle toggling and input-side compression. The always-on ruleset still ships to every other agent.

Upgrading

npx chisle@latest --update

That refreshes every agent that already has Chisle and installs it into none that don't. Two details it exists to handle:

• Plain npx chisle does not upgrade. Every install path skips what is already present, so an upgrade run reports success and changes nothing. --update pairs the refresh with that check.
• @latest matters. npx chisle can serve a cached copy of the package from a previous run, so the pin is what guarantees you get the new one.

Update one agent at a time with --only:

npx chisle@latest --update --only claude     # or: claude plugin update chisle@chisle
npx chisle@latest --update --only pi         # or: pi install npm:chisle
npx chisle@latest --update --only gemini     # or: gemini extensions install https://github.com/JayPokale/Chisle
npx chisle@latest --update --only codex
npx chisle@latest --update --only opencode   # ruleset + skills + the compression plugin
npx chisle@latest --update --only hermes

Cursor, Windsurf, Cline, Kiro and Copilot keep their rule file inside the repo, because that is how those agents load rules:

cd ~/code/my-project
npx chisle@latest --update --only cursor

--update looks for that file in the current directory, so running it from ~ reports "Nothing to update" even when the project is set up correctly. Run it once per repo that has one. Full table, including what each agent's update actually refreshes: INSTALL.md.

Not sure what you are running? npx chisle --list prints the agents it detects, and claude plugin list shows the installed plugin and its version.

Chisle checks npm on session start and mentions it once when a major version is out (cached 3 days, CHISLE_UPDATE_CHECK=0 to silence). Minor and patch releases stay quiet on purpose.

Upgrading to 3.0.0 from 2.x needs nothing: a lite/full/ultra value in CHISLE_DEFAULT_MODE or config.json is no longer meaningful, falls through to the default, and Chisle stays active. It says so once so the setting is not ignored silently. Replace it with on/off or delete it.

Claude Code plugin (marketplace)

claude plugin marketplace add JayPokale/Chisle   # register the marketplace
claude plugin install chisle@chisle              # enable the plugin

Pi package

pi install npm:chisle

The package loads the zero-dependency extension and chisle skill globally. Pi extensions run with your user permissions; review the source before installation. Project-local installs (pi install -l npm:chisle) load only after you trust that project.

Where the savings show up

Two places, both measured rather than estimated:

npx chisle --stats      # what the compressor has saved, cumulative

chisle: tool-output savings

  saved:      88,967 chars  (~22,241 tokens)
  outputs:    18 compressed, 4,943 chars each on average

In Claude Code the statusline badge carries the same number live: [CHISLE] ⇣22k tok. Pi shows it in the footer for the current session.

This is the input axis only, and deliberately so. Chars elided have a real baseline, since the hook knows exactly what it cut. The output axis has none: there is no way to know what the model would have written without the ruleset, which is why that half is measured with A/B benchmark arms instead of a counter. A number that blended the two would be inventing the interesting half.

See what it would do, before it does it

npx chisle --dry-run    # prints every file it would touch, changes nothing
npx chisle --stats      # prints what it has saved, changes nothing

Want the savings measured on your own work rather than ours? Clone the repo and replay the compressor over local transcripts. It reads them locally, writes nothing, and reports the input the hook would have stripped:

git clone https://github.com/JayPokale/Chisle && cd Chisle
node benchmarks/replay-compress.js       # Claude Code
node benchmarks/replay-compress.js pi    # Pi; marginal over Pi's native truncation

---

Numbers

Nothing here is estimated. Every figure below is recomputed from committed raw data; the 2026-07-07 verification writeup re-derived the old claims from scratch, re-ran the whole suite against the competitors' installed plugins, and retired the one claim that didn't survive.

Output axis: vs caveman & ponytail, 20 live tasks

What this suite measures, and what it does not. Every figure below is billed output tokens on single-turn prompts with no tools available. That isolates the ruleset's effect on how the model writes, which is what it was built to measure. It is not whole-session cost: a real agentic session is dominated by tool output and cached input, so a tool can win here and still fail to pay for itself end to end. The input axis below is measured separately, and against its own baseline.

59+ live model runs across two suites (June 4-arm matrix on Haiku + Sonnet sweep; July re-verification run). Arms differ only in the injected system prompt. Billed output tokens vs the no-tool baseline:

| | total bill (all 20 tasks) | average task | worst case | backfires | |---|--:|--:|--:|--:| | caveman | 80% | 98% | 424% | 6 / 20 | | ponytail | 68% | 91% | 227% | 8 / 20 | | Chisle | 52% | 69% | 173% | 1 / 20 |

Chisle wins all four columns: it cut the total 20-task bill nearly in half while the