RTK: A Rust Tool That Cuts AI Coding Assistant Token Usage by 60–90%

When you're coding with something like Claude Code, here's a number that might make you wince: a single `git diff` can burn through thousands of tokens. And the frustrating part? It's not because the AI is struggling to understand your code. It's because the output you're feeding it is full of junk that means absolutely nothing to a language model — color escape codes, blank lines, repeated headers, bloated stack traces. You pay for every one of those tokens, your context window fills up with them, and none of it helps the model do its job.

That's the problem a tool called RTK — Rust Token Killer — sets out to solve. And the angle is clever. Instead of touching the AI or your prompts, it sits in between. It intercepts command output, filters it, and compresses it *before* it ever reaches the AI context. Then it hands the model a clean version. It's a single Rust binary, zero dependencies, supports over a hundred commands, and adds less than ten milliseconds of overhead. The project's sitting at 66,000 stars on GitHub, it's actively maintained, and it's Apache 2.0 licensed.

So let's talk about the philosophy here, because it's the whole point. RTK is *not* mindlessly chopping off the end of your output. It does what you might call semantic compression — it understands each command's output format and tailors the cleanup. It strips ANSI color codes, collapses repeated blocks, removes meaningless whitespace, and keeps the parts that actually carry information. Think about it this way: when an AI looks at `git status`, the thing that matters is "which files changed." Not the wall of formatting and prompt text wrapped around it.

Now, what does that actually save you? The team put together an estimate for a 30-minute Claude Code session on a medium-sized TypeScript or Rust project, and the numbers are pretty striking. Listing files with `ls` and `tree` drops by about 80 percent. Reading files with `cat` — around 70 percent. Searching with `grep` — 80 percent. The git commands are where it gets dramatic: `git status` down 80 percent, `git diff` down 75, and the add-commit-push cycle compressed by a staggering 92 percent. And the test runners — `cargo test`, `npm test`, `pytest`, `go test` — those get slashed by 90 percent, which makes sense when you picture how noisy test output normally is.

Add it all up, and that session goes from roughly 118,000 tokens down to about 23,900. That's an 80 percent cut. Now, the honest caveat: this is an estimate, and real savings depend on your project size. Overall it lands somewhere in the 60 to 90 percent range — but either way, it's substantial.

Getting it running is genuinely simple. If you're on a Mac, `brew install rtk` and you're done. There's also a one-line curl install script for Linux and macOS, or you can build it from source with cargo. Then you wire it into your AI tool — and RTK writes the correct config for each one automatically. There's a flag for GitHub Copilot, a flag for Claude Code, and the same idea for the other tools. After that, your workflow doesn't change at all. Every time the tool runs a shell command, the output quietly passes through RTK's compression before hitting the context. The AI just sees a cleaner version, and you don't have to think about it.

One thing worth clearing up, because it's easy to get confused: RTK operates at the *command-output* layer, and that's a specific spot in the pipeline. It is not response compression on the model's side — it doesn't touch your prompt at all. It only acts on that one segment, the journey from tool output into context. And it's worth contrasting it with something like 9Router, which solves a different problem entirely. 9Router works at the request-routing layer — it's about switching between multiple providers and managing cost. RTK works at the output layer — it's about your context getting blown out by noise. They're complementary, not competing. You can run both together with no conflict. Quick naming heads-up, though: 9Router actually ships its own compression middleware that *also* happens to be called RTK. Different thing. They just share an acronym.

So who's this actually for? Anyone using a CLI-based AI coding tool — Claude Code, Copilot, Codex, Cursor — who regularly has the AI run commands like git, tests, grep, or docker. And here's the rule of thumb: the bigger your project and the more often the AI reaches for the command line, the more you save. The cost of finding out is basically nothing — one binary, under ten milliseconds of overhead, no change to how you work.

So let me leave you with the three things worth holding onto. First: the waste isn't the AI's fault — it's the formatting noise in command output, and RTK kills it at the source before it ever costs you a token. Second: the savings are real and large, on the order of 60 to 90 percent, with the heaviest wins coming from test runs and git operations. And third: it's a zero-friction add — install it, point it at your tool once, and your workflow stays exactly the same while your context window suddenly breathes a lot easier. If you're paying for tokens and letting an AI drive your terminal, this is about as close to free money as it gets.