Skip to content
Skills Library
Programming · Automation

rtk

/rtk

RTK (Rust Token Killer) - Token-optimized command wrapper for reducing token usage in Claude Code. Use when running development commands like cargo, git, npm, vitest, docker, kubectl, or any CLI tool where output verbosity matters. Always prefix commands with 'rtk' to automatically filter and compact output.

Repository
prompts ↗
Licence
MIT
Last repository change
02.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
1
Deprecation

No signals detected. Repository changed on 02.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

RTK (Rust Token Killer) - Token-optimized command wrapper for reducing token usage in Claude Code. Use when running development commands like cargo, git, npm, vitest, docker, kubectl, or any CLI tool where output verbosity matters. Always prefix commands with 'rtk' to automatically filter and compact output.

Triggers from the description

rtk
Original author description

RTK (Rust Token Killer) - Token-optimized command wrapper for reducing token usage in Claude Code. Use when running development commands like cargo, git, npm, vitest, docker, kubectl, or any CLI tool where output verbosity matters. Always prefix commands with 'rtk' to automatically filter and compact output.

How it works

  1. Golden Rule
  2. Build & Compile Commands (80-90% savings)
  3. Test Commands (90-99% savings)
  4. Git Commands (59-80% savings)
  5. GitHub CLI Commands (26-87% savings)
  6. JavaScript/TypeScript Tooling (70-90% savings)
  7. Files & Search Commands (60-75% savings)
  8. Analysis & Debug Commands (70-90% savings)
  9. Infrastructure Commands (85% savings)
  10. Network Commands (65-70% savings)
Original SKILL.md headings · 158 lines, 843 words
SKILL.md preview
---
name: rtk
description: RTK (Rust Token Killer) - Token-optimized command wrapper for reducing token usage in Claude Code. Use when running development commands like cargo, git, npm, vitest, docker, kubectl, or any CLI tool where output verbosity matters. Always prefix commands with 'rtk' to automatically filter and compact output.
---

# RTK (Rust Token Killer)

RTK is a token-optimized command wrapper that dramatically reduces token usage when running development commands in Claude Code. It provides intelligent filtering and compaction for common development workflows.

## Golden Rule

**Always prefix commands with `rtk`**. If RTK has a dedicated filter, it uses it. If not, it passes through unchanged. RTK is always safe to use.

**Important**: Even in command chains with `&&`, use `rtk`:

```bash
# Wrong
git add . && git commit -m "msg" && git push

# Correct
rtk git add . && rtk git commit -m "msg" && rtk git push
```

## Build & Compile Commands (80-90% savings)

```bash
rtk cargo build         # Cargo build output
rtk cargo check         # Cargo check output
rtk cargo clippy        # Clippy warnings grouped by file (80%)
rtk tsc                 # TypeScript errors grouped by file/code (83%)
rtk lint                # ESLint/Biome violations grouped (84%)
rtk prettier --check    # Files needing format only (70%)
rtk next build          # Next.js build with route metrics (87%)
```

## Test Commands (90-99% savings)

```bash
rtk cargo test          # Cargo test failures only (90%)
rtk vitest run          # Vitest failures only (99.5%)
rtk playwright test     # Playwright failures only (94%)
rtk test <cmd>          # Generic test wrapper - failures only
```

## Git Commands (59-80% savings)

```bash
rtk git status          # Compact status
rtk git log             # Compact log (works with all git flags)
rtk git diff            # Compact diff (80%)
rtk git show            # Compact show (80%)
rtk git add             # Ultra-compact confirmations (59%)
rtk git commit          # Ultra-compact confirmations (59%)
rtk git push            # Ultra-compact confirmations
rtk git pull            # Ultra-compact confirmations
rtk git branch          # Compact branch list
rtk git fetch           # Compact fetch
rtk git stash           # Compact stash
rtk git worktree        # Compact worktree
```

**Note**: Git passthrough works for ALL subcommands, even those not explicitly listed.

## GitHub CLI Commands (26-87% savings)

```bash
rtk gh pr view <num>    # Compact PR view (87%)
rtk gh pr checks        # Compact PR checks (79%)
rtk gh run list         # Compact workflow runs (82%)
rtk gh issue list       # Compact issue list (80%)
rtk gh api              # Compact API responses (26%)
```

## JavaScript/TypeScript Tooling (70-90% savings)

```bash
rtk pnpm list           # Compact dependency tree (70%)
rtk pnpm outdated       # Compact outdated packages (80%)
rtk pnpm install        # Compact install output (90%)
rtk npm run <script>    # Compact npm script output
rtk npx <cmd>           # Compact npx command output
rtk prisma              # Prisma without ASCII art (88%)
```

## Files & Search Commands (60-75% savings)

```bash
rtk ls <path>           # Tree format, compact (65%)
rtk read <file>         # Code reading with filtering (60%)
rtk grep <pattern>      # Search grouped by file (75%)
rtk find <pattern>      # Find grouped by directory (70%)
```

## Analysis & Debug Commands (70-90% savings)

```bash
rtk err <cmd>           # Filter errors only from any command
rtk log <file>          # Deduplicated logs with counts
rtk json <file>         # JSON structure without values
rtk deps                # Dependency overview
rtk env                 # Environment variables compact
rtk summary <cmd>       # Smart summary of command output
rtk diff                # Ultra-compact diffs
```

## Infrastructure Commands (85% savings)

```bash
rtk docker ps           # Compact container list
rtk docker images       # Compact image list
rtk docker logs <c>     # Deduplicated logs
rtk kubectl get         # Compact resource list
rtk kubectl logs        # Deduplicated pod logs
```

## Network Commands (65-70% savings)

```bash
rtk curl <url>          # Compact HTTP responses (70%)
rtk wget <url>          # Compact download output (65%)
```

## Meta Commands

```bash
rtk gain                # View token savings statistics
rtk gain --history      # View command history with savings
rtk discover            # Analyze Claude Code sessions for missed RTK usage
rtk proxy <cmd>         # Run command without filtering (for debugging)
rtk init                # Add RTK instructions to CLAUDE.md
rtk init --global       # Add RTK to ~/.claude/CLAUDE.md
```

## Token Savings Reference

| Category | Commands | Typical Savings |
|----------|----------|-----------------|
| Tests | vitest, playwright, cargo test | 90-99% |
| Build | next, tsc, lint, prettier | 70-87% |
| Git | status, log, diff, add, commit | 59-80% |
| GitHub | gh pr, gh run, gh issue | 26-87% |
| Package Managers | pnpm, npm, npx | 70-90% |
| Files | ls, read, grep, find | 60-75% |
| Infrastructure | docker, kubectl | 85% |
| Network | curl, wget | 65-70% |

**Overall average: 60-90% token reduction** on common development operations.

## Installation

RTK is available at: <https://github.com/rtk-ai/rtk>

Follow the installation instructions in the repository to set up RTK in your environment.

## Best Practices

1. **Always use `rtk` prefix**: Even for commands not explicitly listed, RTK will pass them through safely
2. **Chain commands correctly**: Use `rtk` before each command in a chain: `rtk cmd1 && rtk cmd2`
3. **Use `rtk proxy` for debugging**: When you need to see full unfiltered output
4. **Run `rtk discover`**: Periodically check for missed RTK optimization opportunities
5. **Check `rtk gain`**: Monitor your token savings over time

Versions

The database has no other skills named rtk.

Database snapshot: 13.11.2026 · package version 470230990d53 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100rtk-optimizer
    Wrap high-verbosity shell commands with RTK to reduce token consumption. Use when running git log, git diff, cargo test, pytest, or other verbose CLI output that wastes context window tokens.
  • 100phx-mix-compression
    Reduce mix output noise (5-15% token savings) by installing rtk; Use when long mix output floods context.
  • 100odoo-token-killer
    OTK (Odoo Token Killer) - Reduce token consumption by 60-90% on Odoo development operations. Inspired by RTK (Rust Token Killer) by the rtk-ai team. AUTO-USE when running Bash commands during Odoo development. The PreToolUse hook handles transparent rewriting automatically. For…
  • 100tdd-rust
    TDD workflow for RTK filter development. Red-Green-Refactor with Rust idioms. Real fixtures, token savings assertions, snapshot tests with insta. Auto-triggers on new filter implementation.
  • 90rtk-assisted-shell
    Reduce shell output token waste on git, file reads, searches, test runs, linters, logs, and other noisy developer commands with RTK-style filtering. Use when shell-heavy work is flooding the session with logs, diffs, or command output that should be compacted before it reaches the model.
  • 100phx-mix-compression
    Reduce mix output noise (5-15% token savings) by installing rtk filters that compress mix test/credo/dialyzer/compile output before it reaches Claude. Use when long mix output floods context.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.