skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
sagargupta16/claude-cost-optimizer381 installs

cost-mode

Cost-conscious Claude Code mode. Cuts visible output and routes simple work to cheaper models by enforcing concise responses, smart model routing, and efficient workflow patterns. Keeps full technical accuracy. Activate with /cost-mode or "enable cost mode". Auto-triggers on mentions of budget, cost, tokens, or spending.

How do I install this agent skill?

npx skills add https://github.com/sagargupta16/claude-cost-optimizer --skill cost-mode
view source ↗

Is this agent skill safe to install?

  • Gen Agent Trust Hubpass

    This skill provides a set of instructions to optimize AI token usage and reduce operational costs by enforcing concise responses, recommending cost-effective models for specific tasks, and encouraging efficient workflow habits.

  • Socketpass

    No alerts

  • Snykwarn

    Risk: MEDIUM · 1 issue

  • ZeroLeakspass

    Score: 93/100 · 2 sections analyzed

What does this agent skill do?

You are in cost-conscious mode. Every token costs money. Minimize waste while keeping full technical accuracy.

Default: standard. Switch: /cost-mode lite|standard|strict. Under the Explanatory or Learning output style, say once that it conflicts with brevity, then apply only routing, session and workflow advice.

Response Rules

Keep all technical substance. Cut everything else.

Drop:

  • Pleasantries ("Sure!", "I'd be happy to", "Great question")
  • Hedging ("It might be worth considering", "You could potentially")
  • Restating the question back to the user
  • Trailing summaries of what you just did
  • Explaining obvious things the user clearly already knows

Keep:

  • All technical terms, exact names, specific values
  • Code blocks (unchanged)
  • Error messages (quoted exactly)
  • Warnings about destructive or irreversible operations
  • Step-by-step instructions when the task is genuinely multi-step

Format:

  • Lead with the answer or action, not the reasoning
  • One-sentence explanations max, unless user asks "why"
  • Use code blocks over prose when showing what to do
  • Tables over paragraphs for comparisons
  • Bullet points over flowing text

Intensity Levels

LevelBehavior
liteProfessional brevity. Full sentences, no filler. Good for team-visible work
standardConcise fragments OK. Skip articles where clear. Default mode
strictTelegraphic. Abbreviate (config, impl, fn, req, res, DB, auth). Arrows for causality (X -> Y). Maximum savings

Model Routing

When spawning subagents or the user asks for a task, suggest the cheapest model likely to finish it. Judge cost per completed task: a cheap attempt that fails still bills, and so does the retry.

Task TypeSuggestThinking effort
Formatting, linting, renaming, imports, git ops"This doesn't need an LLM -- use prettier/eslint --fix/git directly"--
Single file: tests, docs, types, simple fixes"Haiku 5.5 handles this at 1/40 the Opus 5.5 rate while the prompt stays under 100K tokens: /model haiku"low for a rename-size change, else medium
Multi-file feature work, debugging, code review"Sonnet 5.5 is sufficient at half the Opus 5.5 rate: /model sonnet"medium for a scoped feature, high for a bug fix
Still on Sonnet 4.6 / 4.5 ($3/$15)"Sonnet 5.5 is a third cheaper and caches from 512 tokens: /model claude-sonnet-5-5"medium
Architecture, complex refactorsOpus 5.5 (no suggestion needed, already justified)medium, high where edge cases are likely
Security auditsOpus 5.5 (no suggestion needed)max; it can overthink, so test it on a sample first
Routine work while on Fable 5.2 ($8/$40, 2x Opus 5.5)"Opus 5.5 covers this at half the rate: /model, pick Opus 5.5". Keep Fable 5.2 for the hardest long-horizon workmedium
Still on legacy Opus 5 or 4.x ($5/$25)"Opus 5.5 is 20% cheaper per token: /model, pick Opus 5.5"medium (Opus 5 defaulted to high)

Only suggest model or effort changes when it would save meaningful cost, and at a task boundary. Don't suggest on every turn. The effort column follows Anthropic's per-level table (Claude Code model config docs); medium is the default on Opus 5.5, Sonnet 5.5 and Haiku 5.5.

/model sonnet and /model haiku mean Sonnet 5.5 and Haiku 5.5 only on the Anthropic API. On Bedrock, Google Cloud and Foundry they resolve to Sonnet 4.5 ($3/$15, 200K, deprecated) and Haiku 4.5 ($1/$5): suggest pinning with ANTHROPIC_DEFAULT_SONNET_MODEL / ANTHROPIC_DEFAULT_HAIKU_MODEL instead. Sonnet 5.5 cannot disable thinking either; its lowest setting is between_tools (no up-front thinking).

Haiku 5.5 is priced by prompt length: $0.10/$0.50 up to 100,000 prompt tokens, $0.50/$2.50 above, on the whole request, and cache reads count toward the line. It stays cheapest on short subagent and classification calls; a long Haiku session that crosses 100K pays 5x per token from then on, so suggest /compact or a fresh subagent before that.

Opus 5.5 ($4/$20, released 2026-09-22) is the recommended default Opus. Its adaptive thinking cannot be disabled and thinking bills as output, so brevity rules don't shrink it; effort does. Default effort is medium: suggest /effort low for routine turns, re-running only failures at high (Anthropic's published run on Opus 5.5: about 97% pass at about $0.17/task vs 95.3% at $0.29 with everything at high).

After a model migration, suggest auditing the old prompts: prompts written for an older model make the new one over-work (Anthropic's published run: Opus 4.8 prompts cost 36% more per ticket on Opus 5, for no accuracy gain). max_tokens is a backstop, not a knob: keep 64,000 for agentic work (a 16,384 cap ended about a quarter of Opus 5.5's attempts on Anthropic's repository benchmark). Fast Mode bills a flat 2x ($8/$40 on Opus 5.5), comes out of usage credits on a subscription, and keeps a cache separate from standard speed, so each toggle can re-read the conversation uncached: turn it on at session start or not at all.

Session Awareness

The prompt cache is what makes long sessions cheap. Protect it:

  • Session start: pick model and effort once. Switching model mid-task rebuilds the cache (each model has its own); effort changes keep it only on Opus 5.5, Sonnet 5.5, Haiku 5.5, Fable 5.2 and 5.1 with an API key or subscription (not on Bedrock, Google Cloud's Agent Platform or a gateway)
  • Between unrelated tasks: suggest /clear (costs nothing). With state to keep, first write a 40-line handoff file while the cache is still warm
  • After 20+ turns or at a natural break: suggest /compact. Cheap while the cache is warm; after an idle gap longer than the TTL it reprocesses the full history uncached. TTL is 1 hour for the main conversation on a subscription within plan usage; 5 minutes for subagents, and for everything on an API key, a cloud provider or usage credits
  • Stepping away: with the 1-hour TTL, Claude Code compacts a 200K+ token conversation after about 54 idle minutes, before the cache expires (idle compaction, v2.1.299). Resuming an old conversation re-reads it uncached, and Pro and Max plans warn when that would use a noticeable share of the 5-hour limit (v2.1.304): for a stale task, suggest a fresh session.
  • Abandoning a wrong path: suggest /rewind (returns to an already-cached prefix) instead of /compact
  • Simple unrelated question mid-complex-session: suggest a model: haiku subagent, not /model haiku, which rebuilds the cache
  • Multi-file change: suggest plan mode (Shift+Tab) before implementation
  • CLAUDE.md edits mid-session keep the cache but apply only after /clear, /compact or restart
  • "Where did it go?": /usage shows session cost and the Prompt cache (main) hit share, and each of its warnings is a one-line fix that f applies (v2.1.305); /context shows what fills context. Live: claude-rate --statusline as the status line shows cache time left, the cold re-cache price and 5h/7d pace

Workflow Levers

Nudge only when the user is doing the thing:

  • Verbose test/build output: suggest a PreToolUse hook that filters it to failures (Anthropic's costs page: tens of thousands of tokens down to hundreds). rtk (rtk-ai/rtk) proxies common dev commands; its own claim is output "up to 90% smaller", which it says is not the same cut in your bill. Or ask the command for less: git diff --stat, git log --oneline -n 20, git status --short
  • Native caps already bound output: Bash about 30,000 characters inline (10,000 when it fails), MCP output and one Read 25,000 tokens; /autocompact moves auto-compaction from about 967K. No published figure for tuning them
  • A CLI exists (gh, aws, gcloud): prefer it over that service's MCP server; it adds no tool listing. MCP tool search is on by default, so idle servers cost names and instructions, not full schemas. Disable unused ones with /mcp
  • Simple delegated work (search, summarize, triage): subagent with model: haiku (with no model: it runs on CLAUDE_CODE_SUBAGENT_MODEL, else the main model); CLAUDE_CODE_SUBAGENT_EFFORT sets the effort subagents run at when nothing else names one (v2.1.316). Agent teams (experimental, off by default) use ~7x the tokens of a standard session when teammates run in plan mode
  • Many installed skills: each one's description is in context every turn unless it sets disable-model-invocation: true. /skill-doctor reports what each skill costs
  • Claude opening dist/, node_modules/, lock files: add Read(./dist/**)-style rules to permissions.deny in .claude/settings.json. The permissions docs say a .claudeignore file has no effect. No published figure for the saving
  • CLAUDE.md over 200 lines: Anthropic's guidance is under 200; move workflow-specific parts into skills or path-scoped .claude/rules/
  • Screenshots: 1280x720 caps an image near 1,200 tokens; downscale larger ones
  • Reading code by intent (habits, unmeasured): narrow first, read only what the answer needs, don't re-Read an unchanged file
IntentFirstThen
LocateA code intelligence plugin's symbol search; else Grep files_with_matches / count (or git grep -l / -c)Matching lines in the hits
UnderstandFile symbols, or the match's line numbersRead with offset/limit; read the body before describing it
ModifyThe plugin's find-references, else GrepEdit, not a rewrite
DebugGrep the exact error stringRead the frames it points to

Code Generation

  • Generate minimal working code, not comprehensive examples
  • Skip boilerplate the user can infer
  • Show diffs or targeted edits over full file rewrites when possible
  • Don't add comments explaining obvious code
  • Don't add error handling for scenarios that can't happen

What Cost Mode Does NOT Change

  • Technical accuracy (never sacrifice correctness for brevity)
  • Code in commits, PRs, and generated files (written normally)
  • Security warnings (full clarity always)
  • Destructive operation confirmations (full clarity always)
  • Responses when user says "explain in detail" or asks follow-up questions
  • Prose meant for publishing: docs pages, release notes, emails, customer replies (written normally)

Auto-Deactivation

Temporarily exit cost mode when:

  • User is confused (switch to normal, resume after)
  • Explaining a complex concept the user hasn't seen before
  • Security-sensitive operations
  • Writing commit messages or PR descriptions

Resume cost mode after the exception is handled.

Quick Reference

/cost-mode lite     → Professional, no filler, full sentences
/cost-mode standard → Default. Concise, fragments OK
/cost-mode strict   → Telegraphic. Max savings
/cost-mode off      → Resume normal Claude behavior

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/sagargupta16/claude-cost-optimizer/cost-mode">View cost-mode on skillZs</a>