Rust logo

Rust

OrganizationPopular
ccusage
rust

Guides ccusage Rust implementation work. Use when editing rust/crates or rust/adapters, adapter module layout, crate visibility and hawk findings, embedded pricing, or Rust behavior parity.

Overview

Publisherccusage
Repositoryccusage
Skill namerust
Stars
19K
Forks
871
Bundled files
Instructions only
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by ccusage on GitHub. Read the source before you install it.

Installation

Install the Rust AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/ccusage/ccusage/tree/main/.agents/skills/rust
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/ccusage/ccusage.git /tmp/ccusage
mkdir -p .claude/skills
cp -r /tmp/ccusage/.agents/skills/rust .claude/skills/rust
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Rust in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Rust on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Rust is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

ccusage Rust

The native Rust CLI is the production implementation. rust/adapters/<agent> holds one crate per usage source; rust/crates holds everything not tied to a single source.

Read before editing:

  • rust/adapters/README.md and rust/adapters/AGENTS.md — adapter architecture, the shared-vs-source boundary, module shape, and the checklist for adding an agent. rust/adapters/opencode/src/ is a compact worked example.
  • the crate's own README.md — what it owns and which Crane artifact layer it builds in, which is what a change to it costs. Some adapters add a src/README.md describing the source format.

Two boundaries the crate names hide: ccusage-cli holds the plain argument types while ccusage-cli-parser holds the parser, help renderer, and embedded help JSON that only the binary depends on; rust/crates/ccusage stays thin on purpose, holding dispatch plus the commands that are not an agent report. Behavior two adapters need moves into ccusage-adapter-common (rust/adapters/common) instead of becoming an adapter-to-adapter dependency.

For splitting large modules or hunting duplication, use the reduce-similarities skill.

Behavior Parity

Preserve existing Rust behavior unless the user explicitly scopes a behavior change: report semantics, JSON fields, table columns, progress and spinner text, agent grouping, date filtering, --offline, CLAUDE_CONFIG_DIR, and source-specific environment variables.

origin/main no longer contains the TypeScript adapters. When porting historical behavior, compare against a commit that still has them (git log -1 -- apps/ccusage/src/adapter). Fix the comparison window — current main, a previous release, or that pinned commit — before changing behavior.

Visibility

In this workspace pub is only for what another crate actually uses; everything else is pub(crate), including items other modules in the same crate reach through a module chain.

just hawk reports the difference, and nix flake check gates on the same thing through checks.<system>.ccusage-hawk. When a finding looks wrong, check rust/hawk.toml for a missing shipped entry point before narrowing anything; adding --fix to the underlying cargo hawk check applies the narrowing.

hawk only runs on the toolchain it was built against, so rust-toolchain.toml and nix/cargo-hawk.nix move together — that file's header explains the pinning and lists the hashes a version bump has to change.

https://github.com/astral-sh/hawk

Pricing Embedding

Two snapshots ship inside the binary, both fed by pinned flake inputs and loaded by rust/crates/ccusage-core/src/pricing.rs; rust/crates/ccusage-core/README.md and its build.rs cover the build-time half.

LiteLLM is the primary table. It is compacted into OUT_DIR at build time and never committed: Nix builds and the dev shell hand build.rs the locked snapshot through CCUSAGE_PRICING_JSON_PATH, and the off-by-default fetch-litellm-pricing feature downloads it instead for plain cargo build on platforms Nix cannot target. Keep it off by default — its rustls stack is the most expensive build-dependency in the workspace. just update-litellm-pricing re-locks the input and validates.

models.dev is the committed offline fallback: rust/crates/ccusage-core/src/models-dev-pricing.json and rust/adapters/codex/src/codex-auto-review-fallbacks.json, both regenerated by just gen-models-dev-pricing (just update-models-dev-pricing bumps the pinned input first). rust/crates/ccusage-core/src/fast-multiplier-overrides.json sits beside them but is hand-maintained.

Filtering and compacting belong in build.rs, so runtime code loads the generated build-time snapshot first, then built-in model overrides, then a runtime fetch when not --offline. Cover embedded/offline pricing and context limits with tests.

Validation

Test commands live in the testing skill; performance work and branch-vs-main comparisons in profile; repo-wide format and check recipes in development.

Frequently asked questions

What does the Rust AI skill do?

Guides ccusage Rust implementation work. Use when editing rust/crates or rust/adapters, adapter module layout, crate visibility and hawk findings, embedded pricing, or Rust behavior parity.

Why use Rust on TypingMind?

Because you install it once and use it with any model. Rust is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Rust in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/ccusage/ccusage/tree/main/.agents/skills/rust. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Rust?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Rust?

As many as you like. As long as a model supports skills, you can use Rust with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Rust AI skill free?

It is published on GitHub by ccusage. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇