{
  "conditions": {
    "1": "一行だけ",
    "2": "読者・約束・禁止の指示",
    "3": "文体の見本",
    "4": "他人の記事（公式ドキュメント）",
    "5": "公式情報の箇条書き",
    "6": "自分のメモ",
    "7": "工程分け（構成→執筆→点検→書き直し）",
    "8": "短いメモ（3行）",
    "9": "メモ＋工程分け"
  },
  "metrics": {
    "1": {
      "n": 5,
      "chars": 2526,
      "h2": 5,
      "term": 1.8,
      "bold": 10.4,
      "cost": 0.02396184,
      "fact": {
        "F1 既定20,404": 0,
        "F2 tools空2,184": 0,
        "F3 MCP切18,711": 0,
        "F4 設定切17,078": 0,
        "F5 全部切2,011": 0,
        "F6 system-prompt584": 0,
        "F7 費用0.039/0.005": 0,
        "F8 ツール切が最大": 1,
        "F9 5,613のぶれ": 0,
        "F10 環境依存": 0
      },
      "factavg": 0.2,
      "newnums": 3.4,
      "firstperson": 2.8,
      "sim": 0.25413092607187077
    },
    "2": {
      "n": 5,
      "chars": 2001,
      "h2": 4,
      "term": 0,
      "bold": 1.0,
      "cost": 0.029998639999999997,
      "fact": {
        "F1 既定20,404": 0,
        "F2 tools空2,184": 0,
        "F3 MCP切18,711": 0,
        "F4 設定切17,078": 0,
        "F5 全部切2,011": 0,
        "F6 system-prompt584": 0,
        "F7 費用0.039/0.005": 0,
        "F8 ツール切が最大": 0,
        "F9 5,613のぶれ": 0,
        "F10 環境依存": 0
      },
      "factavg": 0,
      "newnums": 1.6,
      "firstperson": 3.6,
      "sim": 0.2285130009160142
    },
    "3": {
      "n": 5,
      "chars": 1891.2,
      "h2": 4,
      "term": 0,
      "bold": 1.6,
      "cost": 0.03045188,
      "fact": {
        "F1 既定20,404": 0,
        "F2 tools空2,184": 0,
        "F3 MCP切18,711": 0,
        "F4 設定切17,078": 0,
        "F5 全部切2,011": 0,
        "F6 system-prompt584": 0,
        "F7 費用0.039/0.005": 0,
        "F8 ツール切が最大": 0,
        "F9 5,613のぶれ": 0,
        "F10 環境依存": 3
      },
      "factavg": 0.6,
      "newnums": 0.2,
      "firstperson": 2.6,
      "sim": 0.2272050975584255
    },
    "4": {
      "n": 5,
      "chars": 1919,
      "h2": 4,
      "term": 0,
      "bold": 1.0,
      "cost": 0.029626200000000002,
      "fact": {
        "F1 既定20,404": 0,
        "F2 tools空2,184": 0,
        "F3 MCP切18,711": 0,
        "F4 設定切17,078": 0,
        "F5 全部切2,011": 0,
        "F6 system-prompt584": 0,
        "F7 費用0.039/0.005": 0,
        "F8 ツール切が最大": 0,
        "F9 5,613のぶれ": 0,
        "F10 環境依存": 0
      },
      "factavg": 0,
      "newnums": 1,
      "firstperson": 2.4,
      "sim": 0.24093677186819504
    },
    "5": {
      "n": 5,
      "chars": 1693.8,
      "h2": 4,
      "term": 0,
      "bold": 0.0,
      "cost": 0.02993168,
      "fact": {
        "F1 既定20,404": 0,
        "F2 tools空2,184": 0,
        "F3 MCP切18,711": 0,
        "F4 設定切17,078": 0,
        "F5 全部切2,011": 0,
        "F6 system-prompt584": 0,
        "F7 費用0.039/0.005": 0,
        "F8 ツール切が最大": 0,
        "F9 5,613のぶれ": 0,
        "F10 環境依存": 0
      },
      "factavg": 0,
      "newnums": 0,
      "firstperson": 4,
      "sim": 0.2769557341732619
    },
    "6": {
      "n": 5,
      "chars": 2094.2,
      "h2": 3.6,
      "term": 0,
      "bold": 0.0,
      "cost": 0.028448920000000003,
      "fact": {
        "F1 既定20,404": 5,
        "F2 tools空2,184": 5,
        "F3 MCP切18,711": 5,
        "F4 設定切17,078": 5,
        "F5 全部切2,011": 5,
        "F6 system-prompt584": 5,
        "F7 費用0.039/0.005": 5,
        "F8 ツール切が最大": 4,
        "F9 5,613のぶれ": 5,
        "F10 環境依存": 3
      },
      "factavg": 9.4,
      "newnums": 0.4,
      "firstperson": 7.6,
      "sim": 0.37649523693856735
    },
    "7": {
      "n": 5,
      "chars": 2372.6,
      "h2": 4.2,
      "term": 0,
      "bold": 0.0,
      "cost": 0.17321708,
      "fact": {
        "F1 既定20,404": 0,
        "F2 tools空2,184": 0,
        "F3 MCP切18,711": 0,
        "F4 設定切17,078": 0,
        "F5 全部切2,011": 0,
        "F6 system-prompt584": 0,
        "F7 費用0.039/0.005": 0,
        "F8 ツール切が最大": 0,
        "F9 5,613のぶれ": 0,
        "F10 環境依存": 0
      },
      "factavg": 0,
      "newnums": 2.4,
      "firstperson": 8,
      "sim": 0.16455295628839794
    },
    "8": {
      "n": 5,
      "chars": 1906.2,
      "h2": 4,
      "term": 0,
      "bold": 0.0,
      "cost": 0.03167204,
      "fact": {
        "F1 既定20,404": 5,
        "F2 tools空2,184": 5,
        "F3 MCP切18,711": 0,
        "F4 設定切17,078": 0,
        "F5 全部切2,011": 0,
        "F6 system-prompt584": 0,
        "F7 費用0.039/0.005": 0,
        "F8 ツール切が最大": 1,
        "F9 5,613のぶれ": 0,
        "F10 環境依存": 1
      },
      "factavg": 2.4,
      "newnums": 0.8,
      "firstperson": 6.4,
      "sim": 0.23368186200405383
    },
    "9": {
      "n": 5,
      "chars": 2037.6,
      "h2": 3.8,
      "term": 0,
      "bold": 0.0,
      "cost": 0.19327348,
      "fact": {
        "F1 既定20,404": 5,
        "F2 tools空2,184": 5,
        "F3 MCP切18,711": 5,
        "F4 設定切17,078": 5,
        "F5 全部切2,011": 5,
        "F6 system-prompt584": 3,
        "F7 費用0.039/0.005": 5,
        "F8 ツール切が最大": 1,
        "F9 5,613のぶれ": 5,
        "F10 環境依存": 5
      },
      "factavg": 8.8,
      "newnums": 0.8,
      "firstperson": 6.2,
      "sim": 0.30772463701808783
    }
  },
  "ranks": {
    "claude": {
      "1": {
        "6": 1,
        "9": 2,
        "8": 3,
        "7": 4,
        "4": 5,
        "5": 6,
        "3": 7,
        "2": 8,
        "1": 9
      },
      "2": {
        "9": 1,
        "6": 2,
        "8": 3,
        "7": 4,
        "4": 5,
        "2": 6,
        "3": 7,
        "5": 8,
        "1": 9
      },
      "3": {
        "9": 1,
        "6": 2,
        "8": 3,
        "2": 4,
        "7": 5,
        "4": 6,
        "3": 7,
        "1": 8,
        "5": 9
      },
      "4": {
        "9": 1,
        "6": 2,
        "8": 3,
        "2": 4,
        "4": 5,
        "3": 6,
        "7": 7,
        "5": 8,
        "1": 9
      },
      "5": {
        "9": 1,
        "6": 2,
        "8": 3,
        "3": 4,
        "7": 5,
        "2": 6,
        "4": 7,
        "1": 8,
        "5": 9
      }
    },
    "gpt": {
      "1": {
        "9": 1,
        "6": 2,
        "7": 3,
        "8": 4,
        "3": 5,
        "1": 6,
        "4": 7,
        "2": 8,
        "5": 9
      },
      "2": {
        "9": 1,
        "6": 2,
        "7": 3,
        "8": 4,
        "3": 5,
        "4": 6,
        "2": 7,
        "5": 8,
        "1": 9
      },
      "3": {
        "9": 1,
        "6": 2,
        "8": 3,
        "3": 4,
        "1": 5,
        "2": 6,
        "4": 7,
        "5": 8,
        "7": 9
      },
      "4": {
        "9": 1,
        "6": 2,
        "8": 3,
        "2": 4,
        "4": 5,
        "3": 6,
        "7": 7,
        "5": 8,
        "1": 9
      },
      "5": {
        "9": 1,
        "6": 2,
        "8": 3,
        "7": 4,
        "3": 5,
        "2": 6,
        "4": 7,
        "5": 8,
        "1": 9
      }
    }
  },
  "articles": [
    {
      "condition": "1",
      "name": "一行だけ",
      "run": 1,
      "cost_usd": 0.0289,
      "text": "## 「こんにちは」だけで数万トークン？ `claude -p` の入力が膨らむ理由\n\nClaude Codeの非対話モード `claude -p` は、スクリプトやCIから手軽に呼び出せる便利な機能です。ところが、`claude -p \"こんにちは\"` のような一言を投げただけなのに、使用量を確認すると入力トークンが数千〜数万に達していて驚いた、という経験はないでしょうか。\n\n結論から言うと、これは異常ではなく仕様に近い挙動です。`claude -p` は「単なるチャットAPI呼び出し」ではなく、エージェントとしての土台を毎回丸ごと読み込んで起動するためです。本記事では、その内訳と、実践的な削減方法を整理します。\n\n## 入力トークンが大きくなる理由\n\nユーザーが書いた一言は、実際に送信される入力のごく一部にすぎません。リクエストには、おおよそ次のものが毎回含まれます。\n\n**1. システムプロンプト**\nClaude Codeがエージェントとして振る舞うための基本指示です。ツールの使い方、安全上のルール、出力スタイルなどが含まれ、これだけで数千トークン規模になります。\n\n**2. ツール定義**\nBash、ファイル読み書き、検索、編集、Web取得など、組み込みツールのスキーマがすべて入ります。さらにMCPサーバーを接続している場合は、そのツール定義も加わります。MCPサーバーが多いほど、また各サーバーが公開するツールが多いほど、ここが急速に膨らみます。\n\n**3. CLAUDE.md などのメモリ**\nカレントディレクトリや親ディレクトリ、ユーザーのホームにある `CLAUDE.md` は自動で読み込まれます。長い規約やドキュメントを書き込んでいると、その全文が毎回入力に乗ります。\n\n**4. 環境情報**\n作業ディレクトリ、Gitの状態、プラットフォーム、日付などのコンテキストも付加されます。Gitリポジトリ内で実行すると、ブランチや直近のコミットなどの情報が入ることもあります。\n\n**5. スキル・サブエージェント・フックの情報**\n利用可能なスキルやカスタムサブエージェントの説明、フックによる追加コンテキストも対象です。\n\nつまり「こんにちは」の5文字は、数千〜数万トークンの土台の上に載っているだけです。なお、プロンプトキャッシュが効く場合、2回目以降はこの土台の大部分がキャッシュ読み取りとして扱われ、課金上の負担は軽くなります。ただし、キャッシュの有効期間を超えたり、内容が変わったりすると、再び全量が書き込まれます。単発の呼び出しを間隔を空けて繰り返すスクリプトでは、キャッシュの恩恵を受けにくい点に注意が必要です。\n\n## まず現状を計測する\n\n削減の前に、何がどれだけ使われているかを確認しましょう。\n\n- **`--output-format json` を使う**: 結果のJSONに、入力トークン、出力トークン、キャッシュ作成・読み取りのトークン数、コストが含まれます。まずここで総量を把握します。\n- **対話モードで `/context` を実行する**: システムプロンプト、ツール、MCP、メモリ、メッセージがそれぞれ何トークンかを一覧できます。非対話モードと同じ設定の環境で見れば、内訳の目安になります。\n\nたとえば次のように実行し、`usage` の項目を確認します。\n\n```bash\nclaude -p \"こんにちは\" --output-format json\n```\n\n内訳を見ると、「想像以上にMCPツール定義が大きい」「CLAUDE.mdが重い」といったボトルネックが見つかります。そこを優先して潰すのが効率的です。\n\n## 入力トークンを減らす具体的な方法\n\n**1. 不要なMCPサーバーを読み込まない**\n最も効果が出やすい対策です。`--strict-mcp-config` を指定すると、`--mcp-config` で渡した設定だけを使い、普段の設定にあるMCPサーバーを読み込みません。スクリプト用途で必要なサーバーだけを明示的に渡しましょう。\n\n```bash\nclaude -p \"要約して\" --strict-mcp-config --mcp-config ./mcp-min.json\n```\n\n**2. 使うツールを絞る**\n`--tools` オプションで利用可能な組み込みツールを限定できます。テキストの変換や要約だけなら、ツールをほぼ不要にできるため、ツール定義分のトークンを大きく減らせます。`--allowedTools` は「許可の自動承認」であり、定義の読み込み自体を減らす目的には `--tools` のほうが向いています。\n\n**3. CLAUDE.md を軽くする**\n常時必要なルールだけに絞り、詳細な手順書は別ファイルに分けて、必要なときだけ参照させます。また、スクリプト専用の空に近いディレクトリから実行すれば、プロジェクトのメモリを読み込まずに済みます。\n\n**4. システムプロンプトを最小化する**\n`--system-prompt` で既定のシステムプロンプトを置き換えられます。単機能の処理なら短い指示で十分です。ただし、置き換えるとClaude Code本来の挙動指針が失われるため、用途を限定した自動化向けの手段と考えてください。\n\n**5. 不要な拡張を切る**\n使っていないスキル、プラグイン、フックは、スクリプト実行時には無効にしておきます。設定ソースを限定するオプション（`--setting-sources` など）を使うと、ユーザー設定やプロジェクト設定の影響を減らせます。\n\n**6. 軽量なモデルを選ぶ**\nトークン数そのものは変わりませんが、`--model` で小さなモデルを指定すれば、単価ベースのコストを下げられます。分類や整形のような単純なタスクに向いています。\n\n**7. 本当に単純な用途ならAPIを直接使う**\n一言を投げて一言返してほしいだけなら、エージェント機能は不要です。Anthropic APIを直接呼べば、入力は自分が書いたプロンプトだけになります。Claude Codeのツール実行やファイル操作が必要かどうかで使い分けましょう。\n\n## まとめ\n\n`claude -p` の入力トークンが大きいのは、ユーザーの一言とは別に、システムプロンプト、ツール定義、MCP、CLAUDE.md、環境情報といった「エージェントの土台」が毎回送られるからです。\n\n対策の流れは次のとおりです。\n\n1. `--output-format json` や `/context` で内訳を計測する\n2. MCPサーバーとツール定義を絞る（`--strict-mcp-config`、`--tools`）\n3. CLAUDE.mdや拡張を軽量化する\n4. 必要ならシステムプロンプトの置き換えやモデル変更を検討する\n5. 単純な用途ならAPI直接呼び出しに切り替える\n\nなお、オプション名や挙動はバージョンによって変わることがあります。実際に導入する際は `claude --help` や公式ドキュメントで最新の仕様を確認してください。まず計測し、効果の大きいところから削る。この順番で進めれば、無駄なトークンを着実に減らせます。"
    },
    {
      "condition": "1",
      "name": "一行だけ",
      "run": 2,
      "cost_usd": 0.0213,
      "text": "## なぜ `claude -p` は「一言」でも入力トークンが膨らむのか\n\nClaude Codeの非対話モード `claude -p \"こんにちは\"` を実行すると、たった数文字のプロンプトなのに、入力トークンが数千〜数万に達することがあります。コスト集計やレート制限を見て「なぜこんなに？」と驚いた方も多いはずです。\n\n結論から言えば、**送られているのはあなたの一言だけではない**からです。`claude -p` は、対話モードと同じ「エージェントとして動くための土台」をほぼそのまま毎回送信します。\n\n## 入力トークンの内訳\n\n一言のプロンプトの裏で、リクエストには主に次のものが含まれます。\n\n### 1. システムプロンプト\n\nClaude Codeは、コーディングエージェントとして振る舞うための長い指示文を持っています。ツールの使い方、安全上の注意、出力スタイルなどが含まれ、これだけで数千トークン規模になります。\n\n### 2. ツール定義\n\nBash、ファイル読み書き、検索、Web取得、タスク管理など、利用可能なツールのスキーマ（名前・説明・引数のJSON Schema）がすべて入ります。さらに、**MCPサーバーを接続している場合は、そのツール定義も追加**されます。MCPサーバーを複数入れていると、ここが最大の肥大要因になることも珍しくありません。\n\n### 3. プロジェクトのメモリ（CLAUDE.md）\n\nカレントディレクトリや親ディレクトリ、ユーザーホームにある `CLAUDE.md` は自動で読み込まれます。育ててきたルール集が数千トークンあれば、そのまま毎回の入力に乗ります。\n\n### 4. 環境情報・設定由来の追加コンテキスト\n\n作業ディレクトリ、OS、gitの状態、日付といった環境情報に加え、スキル、サブエージェント、フックなどの設定が持つ説明文も含まれます。\n\n### 5. 会話の継続分\n\n`--continue` や `--resume` を使うと、過去のやり取りも入力に含まれます。\n\nこれらが合算されるため、「こんにちは」の一言でも数千〜数万トークンが基本コストとして発生します。\n\n## プロンプトキャッシュとの関係\n\n見かけ上の入力トークンが多くても、実際の課金が同じだけ増えるとは限りません。上記の固定部分はプロンプトキャッシュの対象になりやすく、キャッシュが効けば読み取りコストは通常の入力より大幅に安くなります。\n\nただし注意点があります。\n\n- キャッシュには有効期間があり、間隔が空くと再作成（書き込み）が発生する\n- ツール定義やCLAUDE.mdが変わると、キャッシュが無効になる\n- 単発の `claude -p` を散発的に呼ぶ運用では、毎回「キャッシュ書き込み」になりやすい\n\nログ上では `input_tokens` のほかに `cache_creation_input_tokens` や `cache_read_input_tokens` が分かれて表示されます。**総量だけでなく、この内訳を見る**のが原因調査の第一歩です。`--output-format json` を付けると、使用量やコストを確認できます。\n\n## 入力トークンを減らす方法\n\n### 不要なMCPサーバーを読み込まない\n\n自動化スクリプトに不要なMCPは、`--mcp-config` で必要なものだけを指定し、`--strict-mcp-config` で他の設定を無視させると効果的です。ツール定義の削減は、最も効果が出やすい対策です。\n\n### 使えるツールを絞る\n\n`--allowedTools` や `--disallowedTools` で、そのタスクに必要なツールだけに限定します。要約や文章整形のような用途なら、ツールをほとんど使わずに済みます。\n\n### CLAUDE.mdをスリムにする\n\n非対話の用途では、空のディレクトリや専用のディレクトリで実行すれば、巨大なCLAUDE.mdを避けられます。プロジェクト用のルールは必要最小限にし、詳細は別ファイルに分けて「必要なときだけ読む」構成にしましょう。\n\n### システムプロンプトを見直す\n\n`--system-prompt` 系のオプションで指示を差し替えたり追記したりできます。用途が限定的なら、短い専用プロンプトに置き換える選択肢もあります。ただし、エージェントとしての挙動が変わるため、動作確認は必須です。\n\n### キャッシュを活かす\n\n同じ設定のまま短い間隔でまとめて実行すれば、固定部分がキャッシュから読まれ、コストを抑えられます。バッチ処理は、設定を揃えて連続実行するのが得策です。\n\n### 単純な用途はAPIを直接使う\n\nエージェント機能が不要で、単なるテキスト変換や分類だけなら、Claude Codeではなく Messages API を直接呼ぶ方が、入力は最小限で済みます。\n\n## まとめ\n\n`claude -p` の入力トークンが大きいのは、システムプロンプト、ツール定義、CLAUDE.md、環境情報といった「エージェントの土台」が毎回送られるためです。対策の優先順位は次のとおりです。\n\n1. 使用量の内訳（キャッシュ作成・読み取り）を確認する\n2. 不要なMCPサーバーとツールを外す\n3. CLAUDE.mdと実行ディレクトリを整理する\n4. キャッシュが効く形でまとめて実行する\n5. エージェント機能が不要ならAPIを直接使う\n\n仕組みを理解して設定を絞れば、`claude -p` はスクリプトやCI向けにも、手軽で低コストな道具になります。なお、オプション名や挙動はバージョンで変わる可能性があるため、最新の `claude --help` と公式ドキュメントで確認してください。"
    },
    {
      "condition": "1",
      "name": "一行だけ",
      "run": 3,
      "cost_usd": 0.0244,
      "text": "## 「こんにちは」だけで数万トークン？ `claude -p` の入力トークンが大きくなる理由と削減法\n\nClaude Codeの非対話モード `claude -p` を使うと、スクリプトやCIからAIを手軽に呼び出せます。ところが、`claude -p \"こんにちは\"` のような一言を投げただけなのに、使用量を確認すると入力トークンが数千〜数万に達していて驚いた方も多いのではないでしょうか。本記事では、その理由と、現実的に減らす方法を整理します。\n\n## なぜ短い一言でも入力トークンが大きくなるのか\n\n結論から言うと、あなたが送った文章以外のものが、毎回リクエストに同梱されているためです。`claude -p` は単なるチャットAPIの呼び出しではなく、コーディングエージェントのハーネス全体を起動します。そのため、次のような要素が入力に含まれます。\n\n- **システムプロンプト**：ツールの使い方、安全上のルール、出力スタイルなどの指示一式\n- **ツール定義**：Bash、ファイル読み書き、検索、Web取得など、組み込みツールそれぞれのJSONスキーマと説明文\n- **MCPサーバーのツール定義**：設定しているMCPサーバーが多いほど、ツールの説明文が増える\n- **CLAUDE.md**：ユーザー単位、プロジェクト単位のメモリファイルの内容\n- **環境情報**：作業ディレクトリ、OS、gitの状態など\n- **スキルやサブエージェントの一覧**：利用可能なものの名前と説明\n- **フック等が追加するコンテキスト**：セッション開始時に差し込まれる情報\n\nつまり「こんにちは」は数トークンでも、その前に固定の土台が積み上がります。特にMCPサーバーを複数入れている環境や、長大なCLAUDE.mdを置いている環境では、土台だけで数万トークンになることも珍しくありません。\n\nなお、この固定部分は同じ内容が繰り返し送られるため、プロンプトキャッシュが効きます。キャッシュ読み取りは通常の入力より安価に扱われるので、「トークン数が大きい」ことと「コストが同じ比率で高い」ことは別問題です。ただし、初回や、キャッシュの有効期間が切れた後はキャッシュ書き込みが発生し、レイテンシとコストの両面で響きます。\n\n## まず現状を計測する\n\n闇雲に削る前に、何が入力を占めているかを確認しましょう。\n\n`--output-format json` を付けると、結果に使用量（入力トークン、キャッシュ作成、キャッシュ読み取り、出力など）やコストが含まれます。\n\n```bash\nclaude -p \"hi\" --output-format json\n```\n\n出力の `usage` や `total_cost_usd` を見れば、短い一言でどの程度の土台が乗っているかが分かります。\n\n次に、対話モードで `/context` を実行すると、システムプロンプト、ツール、MCP、メモリファイルなどが何トークンを占めているか内訳を確認できます。どこが大きいかを把握してから手を打つのが近道です。\n\n## 入力トークンを減らす具体的な方法\n\n### 1. 不要なMCPサーバーを読み込まない\n\n効果が大きいのがここです。MCPサーバーはツール定義が毎回入力に載ります。非対話の用途で使わないものは外しましょう。`--mcp-config` で必要なものだけを指定し、`--strict-mcp-config` を併用すると、指定した設定以外を無視できます。\n\n```bash\nclaude -p \"要約して\" --mcp-config ./min-mcp.json --strict-mcp-config\n```\n\n### 2. 使えるツールを絞る\n\nテキスト変換や要約など、ファイル操作やコマンド実行が不要なタスクなら、ツールを絞ることで定義分を減らせます。`--tools` で利用可能な組み込みツールを制限できます（空文字を指定すれば無効化）。`--allowedTools` は許可の設定であって、定義の読み込み自体を減らすものではない点に注意してください。\n\n```bash\nclaude -p \"この文章を英訳して\" --tools \"\"\n```\n\n### 3. CLAUDE.mdを見直す・作業ディレクトリを変える\n\nCLAUDE.mdは毎回読み込まれます。肥大化している場合は、本当に常時必要な内容だけに絞り、詳細は別ファイルに分けて必要なときだけ参照させましょう。また、単発の処理は、CLAUDE.mdのない空のディレクトリで実行するだけでも入力が減ります。\n\n### 4. システムプロンプトを置き換える・簡素化する\n\n`--system-prompt` で既定のシステムプロンプトを置き換えられます。用途が限定的なら、短い指示に差し替えることで大きく削減できます。ただし、既定の指示に含まれる安全面や挙動の調整も外れるため、エージェント的な作業には向きません。純粋なテキスト処理に限るのが無難です。\n\n### 5. 小さなモデルを使い、キャッシュを活かす\n\n`--model` で軽量なモデルを選べば、同じ入力量でも単価を下げられます。また、短い間隔で繰り返し呼ぶ場合は、同一の土台が再利用されてキャッシュ読み取りになりやすくなります。設定や作業ディレクトリを呼び出しごとに変えないことが、キャッシュヒットのコツです。\n\n### 6. そもそも用途を見直す\n\n「単に文章を生成・変換したいだけ」なら、エージェントのハーネスを経由せず、Anthropic APIを直接呼ぶほうが入力は最小になります。`claude -p` は、ファイル操作やツール利用を含むエージェント的な処理にこそ価値があります。\n\n## まとめ\n\n`claude -p` の入力トークンが大きいのは、短い一言の前に、システムプロンプト、ツール定義、MCP、CLAUDE.mdなどの固定の土台が毎回付くためです。対策の流れは次のとおりです。\n\n1. `--output-format json` や `/context` で内訳を計測する\n2. 不要なMCPとツールを外す\n3. CLAUDE.mdを整理し、必要に応じて作業ディレクトリを分ける\n4. 用途が限定的ならシステムプロンプトを置き換える\n5. 軽量モデルとキャッシュを活用する\n6. 単純な生成ならAPIの直接呼び出しを検討する\n\nまずは計測から始めて、大きな要因から順に潰していくのがおすすめです。なお、オプションの名称や挙動はバージョンによって変わることがあるため、実際に使う際は `claude --help` や公式ドキュメントで最新の仕様を確認してください。"
    },
    {
      "condition": "1",
      "name": "一行だけ",
      "run": 4,
      "cost_usd": 0.0225,
      "text": "## 「こんにちは」だけで数万トークン？ `claude -p` の入力が膨らむ理由と削減術\n\nClaude Codeの非対話モード `claude -p` は、スクリプトやCIから手軽にClaudeを呼べる便利な機能です。ところが、`claude -p \"こんにちは\"` のような一言を投げただけなのに、使用量を見ると入力トークンが数千〜数万に達していて驚いた経験はないでしょうか。本記事では、その理由と現実的な減らし方を整理します。\n\n## なぜ短い一言でも入力トークンが大きくなるのか\n\n結論から言うと、あなたが送った一言は入力全体のごく一部にすぎません。`claude -p` は「チャットAPIの薄いラッパー」ではなく、**エージェントとしてのClaude Codeをそのまま1回起動する**コマンドだからです。実際のリクエストには、次のような要素が毎回含まれます。\n\n- **システムプロンプト**：Claude Codeの振る舞い、安全上のルール、出力スタイルなどの指示。これだけで相当な量になります。\n- **ツール定義**：Bash、ファイル読み書き、検索、Web取得、サブエージェントなど、組み込みツールすべてのJSONスキーマと説明文。\n- **MCPサーバーのツール定義**：接続しているMCPサーバーが多いほど、ツール名・説明・スキーマが丸ごと追加されます。1サーバーで数千トークンになることも珍しくありません。\n- **CLAUDE.mdやメモリ**：カレントディレクトリや親ディレクトリ、ユーザー設定にあるCLAUDE.mdが自動で読み込まれます。\n- **環境情報**：作業ディレクトリ、OS、gitの状態、日付などのコンテキスト。\n- **スキルやカスタムエージェントの説明**：導入済みのものはメタ情報がプロンプトに載ります。\n\nつまり「こんにちは」は数トークンでも、その前に**固定費としての数千〜数万トークン**が乗っている状態です。対話モードなら一度の起動で複数ターンに償却できますが、`claude -p` を何度も呼ぶ運用では、呼び出しのたびにこの固定費を支払うことになります。\n\n## まず現状を計測する\n\n減らす前に、何が重いのかを把握しましょう。やみくもに削ると必要な機能まで失います。\n\n- `--output-format json` を付けて実行すると、結果に使用トークン数やコストが含まれます。呼び出しごとに記録しておくと、変更の効果を比較できます。\n- 対話モードで `/context` を実行すると、システムプロンプト、ツール、MCP、メモリなどのカテゴリ別にコンテキストの内訳を確認できます。どこが支配的かを見極める出発点になります。\n- 空のディレクトリで実行した場合と、普段のプロジェクトで実行した場合を比べると、CLAUDE.mdやプロジェクト設定の影響が分かります。\n\n計測してみると、多くの場合「MCPツール定義」と「CLAUDE.md」が想像以上に大きいと気づきます。\n\n## 入力トークンを減らす具体策\n\n計測結果をもとに、効果の大きい順に手を打ちます。\n\n**1. 使わないMCPサーバーを読み込まない**\n`--mcp-config` で必要なサーバーだけを指定し、`--strict-mcp-config` を併用すると、それ以外の設定を無視できます。バッチ処理用のスクリプトなら、MCPなしで動かせるケースも多いはずです。\n\n**2. ツールを絞る**\n`--allowed-tools` や `--disallowed-tools` で権限を制御できます。ツールを使わない単純な質問応答や要約なら、不要なツールを外すことで定義分の入力を抑えられます。利用できるオプションはバージョンで変わるため、`claude --help` で確認してください。\n\n**3. CLAUDE.mdをスリムに保つ**\nCLAUDE.mdは毎回読み込まれるので、詳細な手順書や長い規約を書き込むのは避けましょう。常に必要な要点だけを残し、詳細は別ファイルに分けて「必要なときに読む」運用にします。\n\n**4. 実行場所を変える**\n自動処理用の小さな専用ディレクトリを用意し、そこから実行すれば、プロジェクト固有のメモリや設定の読み込みを避けられます。\n\n**5. システムプロンプトを調整する**\n`--system-prompt` 系のオプションでシステムプロンプトを置き換えたり追記したりできます。ただし置き換えると、Claude Code本来の安全性や挙動の指示が失われるため、用途が限定された処理にとどめるのが無難です。\n\n**6. プロンプトキャッシュを活かす**\n同じ固定部分が繰り返し送られる場合、キャッシュが効けば読み取り分は低い単価で課金されます。短時間に連続して呼ぶ、固定部分を変えない、といった運用でキャッシュヒットしやすくなります。トークン数そのものは減らなくても、コストの観点では大きな差になります。\n\n**7. 呼び出し回数を減らす**\n1件ずつ `claude -p` を呼ぶ代わりに、複数の入力を1回のプロンプトにまとめれば、固定費の支払いは1回で済みます。\n\n## まとめ\n\n`claude -p` の入力トークンが大きいのは、一言の裏でシステムプロンプト、ツール定義、MCP、CLAUDE.mdといった**エージェントの土台**が毎回送られているためです。対策は次の流れで進めると失敗しにくくなります。\n\n1. JSON出力や `/context` で内訳を計測する\n2. 不要なMCPサーバーとツールを外す\n3. CLAUDE.mdを要点だけに絞り、実行ディレクトリを分ける\n4. キャッシュとバッチ化で、固定費の支払い回数とコストを抑える\n\nなお、オプション名や挙動はバージョンアップで変わることがあります。最新の仕様は公式ドキュメントと `claude --help` で確認したうえで、自分の環境で計測しながら調整してみてください。"
    },
    {
      "condition": "1",
      "name": "一行だけ",
      "run": 5,
      "cost_usd": 0.0226,
      "text": "## 「こんにちは」だけで数万トークン？ `claude -p` の入力トークンが大きくなる理由と削減方法\n\nClaude Codeの非対話モード `claude -p` は、スクリプトやCIから手軽にClaudeを呼べる便利な機能です。ところが、`claude -p \"こんにちは\"` のような一言だけを投げても、利用状況を見ると入力トークンが数千〜数万に達していて驚いた方は多いのではないでしょうか。この記事では、その理由と、現実的に減らす方法を整理します。\n\n## 一言なのに入力が大きくなる理由\n\n結論から言うと、あなたが送った一言は全体のごく一部で、残りはClaude Codeが毎回自動で付け加えるコンテキストです。主な内訳は次のとおりです。\n\n**1. システムプロンプト**\nClaude Codeはコーディングエージェントとして動くため、ツールの使い方、安全上のルール、出力スタイルなどを定めた長い指示を毎回含めます。これだけでも数千トークン規模になります。\n\n**2. ツール定義**\nBash、ファイル読み書き、検索、Web取得、サブエージェント起動などのツールごとに、名前・説明・JSONスキーマがリクエストに含まれます。ツール数が多いほど増えます。特にMCPサーバーを接続していると、そのサーバーのツール定義がすべて加算されます。\n\n**3. CLAUDE.mdやメモリ**\nカレントディレクトリや親ディレクトリ、ユーザーホームにある `CLAUDE.md` は自動で読み込まれます。長い規約やプロジェクト説明を書いている場合、それが毎回入力に乗ります。\n\n**4. 環境情報**\n作業ディレクトリ、OS、gitの状態、日付などの環境情報も付加されます。gitリポジトリ内で実行すると、ブランチや直近のコミット、変更状況のサマリも加わることがあります。\n\n**5. スキル・サブエージェント・フック関連**\n利用可能なスキルやエージェントの一覧、フックが追加するコンテキストも、設定していれば入力に含まれます。\n\nつまり `claude -p` は「軽いチャットAPI呼び出し」ではなく、「フル装備のエージェントを起動して一言伝える」処理です。入力が大きいのは仕様どおりの挙動といえます。\n\n## なお、プロンプトキャッシュで実コストは下がる\n\n大きな固定部分は、プロンプトキャッシュの対象になります。同じ内容のプレフィックスが続けて送られると、キャッシュ読み出しとして安い単価で処理されます。そのため、表示上の入力トークンが大きくても、実際の課金やレイテンシは見た目ほど悪くないケースがあります。\n\nただし注意点があります。\n\n- キャッシュには有効期限があり、呼び出し間隔が空くと再び書き込みコストが発生します。\n- 作業ディレクトリや設定を変えるとプレフィックスが変わり、キャッシュが効きません。\n- 単発のスクリプトでは、初回の書き込みコストが毎回かかりがちです。\n\n「大きいけれど安い」場合もあれば、「大きくて高い」場合もあります。まずは利用ログで、通常入力とキャッシュ読み出しの内訳を確認するのがおすすめです。\n\n## 入力トークンを減らす具体的な方法\n\n**1. 余計な設定を読み込ませない場所で実行する**\n`CLAUDE.md` が存在しない空のディレクトリで実行すれば、プロジェクト固有の指示は読み込まれません。単純な変換や要約などの用途なら、専用の作業ディレクトリを用意するのが手軽で効果的です。\n\n**2. MCPサーバーを無効にする**\n使わないMCPサーバーは接続しないようにします。`--mcp-config` で必要なものだけを指定し、`--strict-mcp-config` を併用すれば、それ以外の設定を無視できます。ツール定義の削減効果は大きいです。\n\n**3. 使うツールを絞る**\n`--allowedTools` や `--disallowedTools` でツールを制限できます。ツールが不要な処理であれば、定義の分だけ入力が減ります。なお、オプションの名称や挙動はバージョンで変わるため、`claude --help` で最新の仕様を確認してください。\n\n**4. システムプロンプトを置き換える・最小化する**\n`--system-prompt` などのオプションで、既定のものを自前の短い指示に差し替えられます。コーディング作業を伴わない用途なら有効です。ただし、既定の安全面の指示も外れるため、用途を限定して使いましょう。\n\n**5. ターン数を制限する**\n`--max-turns` で往復を制限すると、ツール呼び出しの連鎖による入力の累積を防げます。エージェントがループすると、毎ターン履歴が再送されて入力が膨らみます。\n\n**6. 軽量なモデルを選ぶ**\n`--model` で小型モデルを指定すれば、トークン数自体は同じでも単価が下がります。分類や整形のような単純なタスクに向いています。\n\n**7. そもそもAPIを直接使う**\n一言を投げて答えを得るだけなら、Claude Codeを経由せずAPIやSDKを直接呼ぶ方が、入力は桁違いに小さくなります。エージェント機能が不要であれば、これが最も確実な方法です。\n\n## まとめ\n\n`claude -p` の入力トークンが大きいのは、システムプロンプト、ツール定義、`CLAUDE.md`、環境情報といった「エージェントとしての装備」が毎回付くためです。対策は次の順で検討すると効率的です。\n\n1. 利用ログで、キャッシュ込みの実コストを確認する\n2. 空のディレクトリで実行し、`CLAUDE.md` の影響を排除する\n3. MCPとツールを必要最小限に絞る\n4. システムプロンプトやモデル、ターン数を調整する\n5. エージェントが不要なら、APIを直接使う\n\n「何が入力に含まれているか」を理解すれば、用途に合わせた最適化は難しくありません。自動化に組み込む前に、一度設定を見直してみてください。"
    },
    {
      "condition": "2",
      "name": "読者・約束・禁止の指示",
      "run": 1,
      "cost_usd": 0.0268,
      "text": "## `claude -p` は一言でも入力トークンが大きくなる\n\n`claude -p \"hello\"` のように短い一言だけを投げても、使用量を見ると入力トークンが数千から数万になることがあります。自分が書いたのは数文字なのに、なぜそうなるのか。\n\n理由は、`claude -p` が送っているのはあなたのプロンプトだけではないからです。非対話モードでも、Claude Codeは対話モードと同じ土台を組み立ててモデルに渡します。主な中身は次のとおりです。\n\n- システムプロンプト（Claude Codeの動作指示）\n- 組み込みツールの定義（ファイル読み書き、シェル実行、検索など。ツールごとに説明文とスキーマがある）\n- 接続しているMCPサーバーのツール定義\n- カレントディレクトリや親ディレクトリにある `CLAUDE.md`、ユーザー設定の `CLAUDE.md`\n- スキルやサブエージェントの説明\n- 環境情報（作業ディレクトリ、OS、gitの状態など）\n\nつまり「一言」の前に、毎回かなりの固定部分が付きます。MCPサーバーを複数入れていたり、`CLAUDE.md` が長かったりすると、この固定部分だけで簡単に膨らみます。スクリプトから何十回も呼ぶ場合、この固定部分が呼び出しの回数ぶん積み重なります。\n\n## まず自分の環境で測る\n\n減らす前に、何がどれだけ入っているかを測ります。推測で削ると、効かない場所をいじることになります。\n\n最小の計測は、JSON出力で使用量を見る方法です。\n\n```bash\nclaude -p \"hi\" --output-format json\n```\n\n出力のJSONには `usage` が含まれ、`input_tokens`、`cache_creation_input_tokens`、`cache_read_input_tokens`、`output_tokens` などが見えます。フィールド名や構成はバージョンで変わることがあるので、手元の出力を正としてください。`jq` があれば絞り込めます。\n\n```bash\nclaude -p \"hi\" --output-format json | jq '.usage'\n```\n\n見るときの注意点が一つあります。`input_tokens` だけを見て「少ない」と判断しないことです。プロンプトキャッシュが効いている場合、固定部分は `cache_read_input_tokens` 側に計上され、`input_tokens` は小さく見えます。入力の総量を知りたいなら、`input_tokens`、`cache_creation_input_tokens`、`cache_read_input_tokens` を合算して見ます。\n\n次に、条件を変えて差分を取ります。\n\n1. 何も置いていない空のディレクトリで実行する（`CLAUDE.md` の影響を除く）\n2. プロジェクトのディレクトリで実行する\n3. MCP設定を外して実行する\n\nこの3つの合計を比べれば、固定部分の内訳がだいたい分かります。空のディレクトリでも残る分が、Claude Code本体の基本コストです。そこからの増分が、あなたの環境が足している分です。\n\n## キャッシュの仕組みを理解して使う\n\nプロンプトキャッシュは、リクエストの先頭から同じ内容が続く部分を再利用する仕組みです。システムプロンプトやツール定義のように毎回同じ部分は、2回目以降にキャッシュから読まれ、通常の入力より安く、速く処理されます。\n\n押さえておくことは二つです。\n\n- キャッシュは先頭からの一致で効く。途中の内容が変わると、そこから後ろは再利用されない\n- キャッシュには有効期限があり、呼び出しの間隔が空くと切れる。期限の長さは設定やプランによって異なるので、ドキュメントで確認してください\n\nここから、スクリプトでの実践的な指針が出ます。\n\n- 短い間隔で連続して呼ぶと、2回目以降は固定部分がキャッシュから読まれやすい\n- 呼び出しごとに変わる情報（日時、ランダムなID）を `CLAUDE.md` や追加のシステムプロンプトに入れない。先頭側が変わると、後ろ全体のキャッシュが無駄になる\n- 変わる情報はプロンプトの末尾側、つまりユーザー入力の側に置く\n\n先ほどの計測で、同じコマンドを2回続けて実行してみてください。2回目に `cache_read_input_tokens` が増え、`cache_creation_input_tokens` が減っていれば、キャッシュが効いています。\n\n## 固定部分を減らす\n\n測定で大きな項目が見えたら、そこから削ります。効果が大きい順に試すのが現実的です。\n\n**MCPサーバーを絞る。** ツール定義はサーバーごとに入ります。そのスクリプトで使わないサーバーは外します。`--mcp-config` で必要なものだけを指定し、`--strict-mcp-config` を併用すると、指定した設定以外を読まなくなります。\n\n**使うツールを限定する。** `--allowedTools` は許可の指定で、ツール定義そのものを減らすものではありません。ツール自体を減らしたい場合は、`--tools` で利用可能な組み込みツールを絞れるか、`claude --help` で手元のバージョンの対応を確認してください。\n\n**`CLAUDE.md` を短くする。** 長い手順書や、そのスクリプトに関係ない規約が入っていないか見直します。自動化専用の短い指示だけを置いた専用ディレクトリを作り、そこから実行する方法もあります。\n\n**システムプロンプトを自分で制御する。** `--append-system-prompt` は既定のものに追記するだけなので、増やす方向です。置き換えのオプションがある場合は、既定の指示が失われる点を理解したうえで試してください。\n\n**不要な出力と往復を避ける。** 入力トークンは会話が続くほど積み上がります。1回で済む作業を何ターンにも分けない、`--max-turns` で上限を決める、といった設計でも総量は下がります。\n\n削るたびに、最初の計測コマンドをもう一度実行し、合計がどう動いたかを記録してください。変更を一つずつ入れて測ると、どの設定が効いたのかが分かります。まず空のディレクトリで基本コストを知り、次にMCPを外し、最後に `CLAUDE.md` を見直す。この順番で、自分の環境の数字を自分で確かめられます。"
    },
    {
      "condition": "2",
      "name": "読者・約束・禁止の指示",
      "run": 2,
      "cost_usd": 0.0305,
      "text": "## 一言でも入力トークンが大きくなる理由\n\n`claude -p \"こんにちは\"` と打っても、モデルに届くのはその一言だけではありません。Claude Code は毎回、次のようなものをまとめて送っています。\n\n- Claude Code 本体のシステムプロンプト\n- Read、Edit、Bash など組み込みツールの定義\n- 接続している MCP サーバーのツール定義\n- カレントディレクトリや親ディレクトリにある CLAUDE.md\n- 作業ディレクトリなどの環境情報\n\n非対話モードでも、これらは対話モードと同じように読み込まれます。入力トークンは「自分のプロンプト + 固定の土台」になり、短い質問ほど土台の割合が目立ちます。MCP サーバーを何個もつないでいる環境では、ツール定義だけでもかなりの量になります。\n\n## まず自分の環境で測る\n\n減らす前に、今どれだけ使っているかを見ます。`--output-format json` を付けると、結果と一緒に使用量が返ってきます。\n\n```bash\nmkdir -p /tmp/empty && cd /tmp/empty\nclaude -p \"こんにちは\" --output-format json | jq '.usage'\n```\n\n見るのは次の3つです。\n\n- `input_tokens`\n- `cache_creation_input_tokens`\n- `cache_read_input_tokens`\n\n`input_tokens` だけを見ると小さな数字に見えることがあります。土台の多くはキャッシュ関連の2項目に入るためです。実際の入力量は3つの合計で考えてください。\n\n次に、普段スクリプトを動かすプロジェクトのディレクトリで同じコマンドを実行し、合計を比べます。差分が CLAUDE.md や設定ファイル、MCP による増加分の目安になります。\n\n## 土台を削る\n\n測った数字を見ながら、不要なものを1つずつ外して再測定します。\n\n```bash\n# 組み込みツールを使わせない（文章生成や分類だけならこれで足りる）\nclaude -p \"要約して: ...\" --tools \"\"\n\n# MCP は指定したものだけを読み込む\nclaude -p \"...\" --strict-mcp-config --mcp-config ./mcp.json\n\n# 読み込む設定ファイルの範囲を絞る\nclaude -p \"...\" --setting-sources user\n\n# システムプロンプトを自前の短いものに置き換える\nclaude -p \"...\" --system-prompt \"あなたは校正担当です。誤字だけ指摘してください。\"\n```\n\n自動化では、作業ディレクトリを空のディレクトリにするだけでも CLAUDE.md の読み込みを避けられます。対話で使う設定とは別に、スクリプト専用のディレクトリを用意する運用が扱いやすいです。\n\n注意点として、ツールを外すとファイル操作やコマンド実行はできなくなります。`--system-prompt` で置き換えると、Claude Code 標準の指示も一緒に消えます。用途に合わせて選んでください。オプションの名前や挙動はバージョンで変わることがあるので、`claude --help` で手元のバージョンを確認してから試すと安全です。\n\n## キャッシュを効かせる\n\n土台は毎回ほぼ同じ内容なので、プロンプトキャッシュが効きます。1回目は `cache_creation_input_tokens` に計上され、同じ内容の先頭部分が再び送られると `cache_read_input_tokens` に計上されます。読み取り側のほうが料金は安く設定されています。\n\nキャッシュには有効期限があります。続けて呼ぶ処理では効きやすく、間隔が空くと作り直しになります。次のことを意識してください。\n\n- 同じ設定のコマンドを短い間隔でまとめて実行する\n- 実行ごとに変わる値(日時、乱数など)を、システムプロンプトの先頭に入れない\n- 毎回変わる部分は、プロンプトの後ろのほうに置く\n- 実行ごとにオプションや MCP 構成を切り替えない(先頭部分が変わるとキャッシュが使えなくなる)\n\n同じコマンドを2回続けて実行し、2回目の `cache_read_input_tokens` が増えていれば、キャッシュが効いています。\n\n測定、削減、再測定を1つずつ繰り返せば、自分の用途にとって何が効いたのか数字で確かめられます。まずは空のディレクトリで `--output-format json` を試すところから始めてください。"
    },
    {
      "condition": "2",
      "name": "読者・約束・禁止の指示",
      "run": 3,
      "cost_usd": 0.0314,
      "text": "## 一言でも入力が大きくなる理由\n\n`claude -p \"hi\"` と打っても、モデルに届くのは「hi」の2文字だけではありません。Claude Code は毎回、次のような土台を一緒に送っています。\n\n- システムプロンプト\n- 組み込みツール(Bash、Read、Edit など)の定義\n- 有効な MCP サーバーが持つツールの定義\n- CLAUDE.md、メモリ、スキルの一覧\n- 作業ディレクトリや git の状態などの環境情報\n\nこれらは対話モードでも非対話モードでも変わりません。ユーザーの入力が短くても、土台の分だけ入力トークンは最初から大きくなります。MCP サーバーを多く入れている環境や、長い CLAUDE.md があるプロジェクトでは、特に差が出ます。\n\n## まず自分の環境で測る\n\n減らす前に、何トークン使っているかを見ます。`--output-format json` を付けると、結果に使用量が含まれます。\n\n```bash\nclaude -p \"hi\" --output-format json | jq '{usage: .usage, cost: .total_cost_usd}'\n```\n\n見るのは `usage` の中の3つです。\n\n- `input_tokens`: キャッシュにかからなかった通常の入力\n- `cache_creation_input_tokens`: キャッシュを新しく作った分\n- `cache_read_input_tokens`: キャッシュから読み出した分\n\n同じコマンドを続けて2回実行してみてください。1回目は `cache_creation_input_tokens` が大きく、2回目は同じ土台が `cache_read_input_tokens` に移るのが見えるはずです。プロンプトキャッシュは、リクエストの先頭から同じ内容が続いている部分を再利用する仕組みで、読み出し分は通常の入力より安く扱われます。\n\nつまり見るべき数字は「合計トークン」だけではありません。`total_cost_usd` も合わせて記録しておくと、あとで比較しやすくなります。\n\n## 土台を小さくする\n\n測定の基準ができたら、1つ変えるごとに測り直します。まとめて変えると、どれが効いたのか分からなくなります。\n\n1. 空のディレクトリで実行する。プロジェクトの CLAUDE.md を読み込まなくなります。\n2. 使うツールを絞る。`--tools \"Read,Grep\"` のように指定します。ツールが要らない処理なら `--tools \"\"` です。\n3. MCP を切る。`--strict-mcp-config` を付け、`--mcp-config` を渡さなければ、MCP のツール定義は入りません。\n4. スキルを切る。`--disable-slash-commands` で無効にできます。\n5. システムプロンプトを置き換える。`--system-prompt \"...\"` で既定のものと差し替えられます。\n\n```bash\ncd \"$(mktemp -d)\"\nclaude -p \"hi\" --tools \"\" --strict-mcp-config --disable-slash-commands \\\n  --output-format json | jq '.usage'\n```\n\n最後のシステムプロンプトの置き換えは、ツールを使わない単純な変換や要約向けです。既定のプロンプトにはツールの使い方などの指示が含まれているため、置き換えると挙動が変わります。出力の品質も一緒に確認してください。\n\nフラグの名前や挙動はバージョンで変わることがあります。動かないときは `claude --help` で手元のバージョンの一覧を確認してください。\n\n## キャッシュを効かせて繰り返し実行する\n\nスクリプトから何度も呼ぶ場合は、小さくするだけでなく、キャッシュが効く形に揃えることも効果があります。キャッシュは先頭から同じ部分にだけ効くので、次の点を守ります。\n\n- 毎回同じフラグで呼ぶ。ツールの構成が変わると、先頭の内容が変わってキャッシュが外れます。\n- 毎回同じディレクトリで呼ぶ。環境情報が土台に含まれるためです。\n- 毎回変わる内容(入力データなど)は、プロンプトの後ろに置く。\n- 呼び出しの間隔を空けすぎない。キャッシュには有効期限があり、切れると作り直しになります。\n\n確認は先ほどのJSONで行えます。2回目以降の `cache_read_input_tokens` が大きく、`cache_creation_input_tokens` が小さければ、期待どおり効いています。逆なら、フラグやディレクトリが呼び出しごとに変わっていないかを疑ってください。\n\n測る、1つ変える、また測る。この繰り返しで、自分のスクリプトに合った構成が見つかります。"
    },
    {
      "condition": "2",
      "name": "読者・約束・禁止の指示",
      "run": 4,
      "cost_usd": 0.0324,
      "text": "## 一言でも入力が大きくなる理由\n\n`claude -p \"hi\"` と打つと、送られるのは「hi」だけではありません。毎回のリクエストには、次のものが一緒に付きます。\n\n- Claude Codeのシステムプロンプト\n- 組み込みツール（Bash、Read、Editなど）の定義\n- 接続中のMCPサーバーが持つツールの定義\n- CLAUDE.mdやスキルの説明\n- 作業ディレクトリに関する情報\n\nツールの定義はJSONスキーマで書かれていて、1つ1つが意外と長くなります。MCPサーバーを何本もつないでいると、その分だけ増えます。`-p` は表示が非対話になるだけで、中で動くのは対話モードと同じエージェントです。だから一言でも、土台の分が毎回乗ります。\n\n## まず自分の環境で測る\n\n推測で削る前に、数字を見ます。JSON出力にすると使用量が取れます。\n\n```bash\nclaude -p \"hi\" --output-format json | jq '.usage'\n```\n\n見るのは `input_tokens`、`cache_creation_input_tokens`、`cache_read_input_tokens` の3つです。キャッシュ分は別の項目に出るので、`input_tokens` だけ見ると小さく見えてしまいます。実際の入力の大きさは3つの合計で考えてください。\n\n次に、場所を変えて同じコマンドを実行します。\n\n```bash\nmkdir -p /tmp/empty && cd /tmp/empty\nclaude -p \"hi\" --output-format json | jq '.usage'\n```\n\n普段のプロジェクトでの結果と比べると、CLAUDE.mdや設定、MCPがどれだけ効いているかが分かります。対話モードで `/context` を実行すると、何が何トークンを占めているかの内訳も見られます。\n\n## 減らす方法を試す\n\n次のオプションが効きます。変更は1つずつにして、そのたびに測ってください。\n\n```bash\n# 組み込みツールを無効にする（定義が送られなくなる）\nclaude -p \"hi\" --tools \"\" --output-format json | jq '.usage'\n\n# MCPを読み込まない（--mcp-config を渡さなければ0本）\nclaude -p \"hi\" --strict-mcp-config --output-format json | jq '.usage'\n\n# システムプロンプトを自分のものに置き換える\nclaude -p \"hi\" --system-prompt \"Answer briefly.\" --output-format json | jq '.usage'\n```\n\nほかに、`--setting-sources` で読み込む設定の範囲を絞る方法や、`--disable-slash-commands` でスキルを切る方法があります。CLAUDE.mdを短く保つのも地道に効きます。\n\nオプションはバージョンによって増減します。手元で使えるかは `claude --help` で確認してください。ツールを外すと、Claudeはファイルを読んだりコマンドを実行したりできなくなります。テキストの要約や分類のような、道具が要らない処理から試すと安全です。\n\n## キャッシュを味方にする\n\n削れない分は、キャッシュで安くします。リクエストの先頭部分が前回と同じなら、その部分はキャッシュから読まれ、通常の入力とは別枠で扱われます。確かめ方は簡単で、同じコマンドを続けて2回実行します。\n\n```bash\nfor i in 1 2; do\n  claude -p \"hi\" --output-format json | jq -c '.usage'\ndone\n```\n\n2回目で `cache_read_input_tokens` が増えていれば、キャッシュが効いています。キャッシュには有効期限があり、間が空くと作り直しになります。スクリプトで繰り返し呼ぶなら、間隔を空けすぎない構成が向いています。\n\nもう1つ、キャッシュは先頭から一致した部分にだけ効きます。先頭に近い位置へ日時や実行ごとに変わるIDを入れると、以降が毎回別物になります。固定の指示は前に、変わる内容は後ろに置いてください。`--tools` やシステムプロンプトを変えた直後は先頭が変わるので、最初の1回は作り直しになります。\n\n測る、1つ変える、また測る。この繰り返しで、自分の環境でどこが重いのかが分かります。"
    },
    {
      "condition": "2",
      "name": "読者・約束・禁止の指示",
      "run": 5,
      "cost_usd": 0.0288,
      "text": "## 一言なのに入力が大きくなる理由\n\n`claude -p \"こんにちは\"` で送られるのは、その一言だけではありません。毎回、次のものがまとめてモデルに渡されます。\n\n- Claude Code 本体のシステムプロンプト\n- Bash、Read、Edit など組み込みツールの定義\n- 接続中のMCPサーバーが持つツールの定義\n- CLAUDE.md、環境情報（作業ディレクトリやOSなど）\n\nツール定義は、名前、説明文、引数のJSONスキーマがそのままテキストとして入ります。MCPサーバーを何台も入れていると、この部分だけで大きくなります。対話モードでもスクリプトでも中身は同じで、`-p` だから軽くなるわけではありません。\n\n## まず自分の環境で測る\n\n推測で削ると、効いたかどうか分かりません。先に `--output-format json` で実測します。\n\n```bash\nclaude -p \"hi\" --output-format json | jq '.usage'\n```\n\n見るのは次のフィールドです。\n\n- `input_tokens`: キャッシュにのらなかった入力\n- `cache_creation_input_tokens`: 今回キャッシュに書き込んだ入力\n- `cache_read_input_tokens`: キャッシュから読んだ入力\n\n実際に送った入力の総量は、この3つの合計です。`input_tokens` だけが小さくても、安心はできません。`total_cost_usd` も同じJSONに出るので、金額での比較にも使えます。\n\n同じコマンドを続けて2回実行すると、2回目は `cache_read_input_tokens` が増えるはずです。これが次のキャッシュの話につながります。\n\n## 条件を1つずつ変えて減らす\n\n一度に全部変えず、1つ変えるたびに上のコマンドで測り直してください。どれが効いたかが分かります。\n\n```bash\n# 組み込みツールを無効にする\nclaude -p \"hi\" --tools \"\" --output-format json | jq '.usage'\n\n# MCPを読み込まない(--mcp-config を渡さなければ0台になる)\nclaude -p \"hi\" --strict-mcp-config --output-format json | jq '.usage'\n\n# システムプロンプトを自前の短いものに置き換える\nclaude -p \"hi\" --system-prompt \"Answer briefly.\" --output-format json | jq '.usage'\n```\n\nほかに、CLAUDE.md のないディレクトリで実行する方法もあります。プロジェクトの CLAUDE.md が読まれなくなります。お使いのバージョンに `--bare` があれば、フック、プラグイン、CLAUDE.md の自動読み込みなどを省く用途で使えます。`claude --help` で確認してください。\n\n注意点が2つあります。`--tools \"\"` にすると、ファイル操作やコマンド実行はできなくなります。要約や分類のように、文章を返すだけの処理向けです。また `--system-prompt` で置き換えると、Claude Code 本来の振る舞いに頼れなくなります。出力が変わっていないか、必ず確認してください。\n\n## 減らせない分はキャッシュに任せる\n\n最小構成にしても、入力はゼロにはなりません。残りは、プロンプトキャッシュを効かせて安くします。キャッシュは、リクエストの先頭から同じ内容が続く部分を再利用する仕組みです。キャッシュから読んだ分は、通常の入力より安く扱われます。\n\nスクリプトに組み込むときは、次の点に気をつけます。\n\n- 毎回変わる部分(対象ファイルの内容、日時など)は、プロンプトの後ろに置く。\n- `--system-prompt` に日時やIDなど、実行ごとに変わる値を入れない。先頭が変わると、その先は再利用されません。\n- 連続して呼ぶ処理は、間を空けすぎない。キャッシュの保持時間は数分程度と短く、空くと再び書き込みから始まります。保持時間はプランやバージョンで変わりうるので、手元で確かめてください。\n\n確認は、測定と同じコマンドを2回続けて実行するだけです。2回目の `cache_read_input_tokens` が増えていれば、効いています。増えないなら、先頭のどこかが毎回変わっていると疑ってください。\n\nまずは `hi` を1回投げて、自分の環境の内訳を見るところから始めてください。"
    },
    {
      "condition": "3",
      "name": "文体の見本",
      "run": 1,
      "cost_usd": 0.0301,
      "text": "## 「hi」を投げても、荷物は一緒に付いてくる\n\n`claude -p \"hi\"` と打つ。送ったのは2文字です。なのに入力トークンは数千、環境によってはそれ以上になります。\n\n理由は単純で、Claude Codeは質問と一緒に「仕事道具一式」を毎回送るからです。\n\n- システムプロンプト（Claude Codeの動き方の説明書）\n- 組み込みツールの定義（Bash、Read、Editなど）\n- 接続しているMCPサーバーのツール定義\n- スキルやスラッシュコマンドの説明\n- CLAUDE.mdや設定ファイルの中身\n\n`-p` は対話しないだけで、中身は普通のClaude Codeです。道具箱を背負ったまま、一言だけ話しかけているわけです。MCPサーバーを何本も入れている人ほど、箱は重くなります。\n\n## 自分の環境で測ってみる\n\n数字は環境ごとに違うので、まず測りましょう。\n\n```bash\nclaude -p \"hi\" --output-format json | jq '.usage'\n```\n\n見るのは次の3つです。\n\n- `input_tokens`\n- `cache_creation_input_tokens`\n- `cache_read_input_tokens`\n\nここに落とし穴があります。`input_tokens` だけ見ると「意外と少ない」と感じるはずです。キャッシュ分が別枠だからです。実際に送った量は3つの合計で見てください。\n\n同じコマンドを続けて2回打つと、2回目は `cache_read_input_tokens` が増えて、書き込み分が減ります。キャッシュが効いている証拠です。\n\n## 減らす4つの手\n\nどれも1回ずつ足して、足すたびに測り直してください。何が効いたか分かります。\n\n**1. 使わないMCPを切る**\n\n```bash\nclaude -p \"hi\" --strict-mcp-config --output-format json\n```\n\n`--mcp-config` で指定したもの以外を読み込まなくなります。指定しなければゼロです。たいてい最初に効く手です。\n\n**2. ツールを絞る**\n\n```bash\nclaude -p \"hi\" --tools \"Read,Grep\"\n```\n\n要約や分類だけなら、Bashも編集ツールもいりません。`--tools \"\"` で全部外すこともできます。\n\n**3. 設定とスキルを読まない**\n\n`--setting-sources` で読む設定の範囲を絞れます。`--disable-slash-commands` でスキルも外れます。空のディレクトリで実行するだけでも、プロジェクトのCLAUDE.mdは読まれなくなります。\n\n**4. システムプロンプトを差し替える**\n\n`--system-prompt` で、既定の長い説明書を自分の短い指示に置き換えられます。ただしClaude Codeらしい振る舞いも消えるので、用途は選んでください。\n\nバージョンによっては、こうした読み込みをまとめて省くフラグもあります。`claude --help` で確認してみてください。\n\n## キャッシュは「減らす」より「当てる」\n\nここまでは荷物を軽くする話でした。もう一つ、荷物が重くても安くなる道があります。プロンプトキャッシュです。\n\n先頭から同じ内容が続くと、その部分は再利用されます。再利用分は通常の入力より安く扱われます（料金は公式の価格ページで確認してください）。保持時間は限られるので、スクリプトで何度も呼ぶなら短い間隔でまとめて回すのが向いています。\n\nコツは、先頭を変えないことです。\n\n- 呼び出しごとに `--tools` やMCPの構成を変えない\n- 日時や乱数など毎回変わる文字列を、システムプロンプトの先頭に入れない\n- 変わる部分（今回の質問）は最後に置く\n\n軽くして、さらにキャッシュを当てる。この二段構えが、自動化で効いてきます。\n\nまずは `hi` を1回測って、MCPを外して、もう1回測ってみてください。数字が動く瞬間は、ちょっと楽しいですよ。"
    },
    {
      "condition": "3",
      "name": "文体の見本",
      "run": 2,
      "cost_usd": 0.0349,
      "text": "`claude -p \"hi\"` と打っただけなのに、入力トークンが数千も出ている。初めて測った人は、たいてい一度は目を疑います。\n\n犯人は、あなたの一言ではありません。毎回、裏で一緒に送られている「荷物」です。\n\n## 一言の裏に付いてくるもの\n\n`claude -p` は、単なる一問一答のAPI呼び出しではありません。Claude Codeというエージェントを、そのまま一回だけ動かしています。だから、あなたのプロンプトの前に、こんなものが並びます。\n\n- Claude Code本体のシステムプロンプト\n- 組み込みツール（ファイルの読み書き、シェル実行など）の定義\n- 接続しているMCPサーバーのツール定義\n- カレントディレクトリにあるCLAUDE.mdや各種設定\n\nツール定義は、1個ずつが説明文とスキーマのかたまりです。MCPサーバーを足すほど、荷物は増えます。\n\nつまり「短い一言で数千トークン」は、バグではなく仕様です。減らせるのは、この荷物のほうです。\n\n## まず測る\n\n減らす前に、自分の環境の数字を見ましょう。\n\n```bash\nclaude -p \"hi\" --output-format json | jq '.usage'\n```\n\n見るのは次の3つです。\n\n- `input_tokens`\n- `cache_creation_input_tokens`\n- `cache_read_input_tokens`\n\nここに落とし穴があります。`input_tokens` だけ見ると、やけに小さい。キャッシュされた分が別の欄に入っているからです。実際の入力量は3つの合計で見ます。\n\n```bash\nclaude -p \"hi\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\n同じコマンドを続けて2回打つと、1回目は `cache_creation`、2回目は `cache_read` が増えるはずです。先頭が同じ部分は、2回目以降キャッシュから読まれます。読み取りは通常の入力より安く課金されます（正確な倍率は公式の料金ページで確認してください）。\n\n## 荷物を減らす実験\n\n一度に全部変えると、何が効いたか分かりません。1個ずつ変えて、そのつど測ります。\n\n1. 実行ディレクトリを変える。空のディレクトリで同じコマンドを打って、差を見ます。差分がCLAUDE.mdなどプロジェクト由来の分です。\n2. ツールを絞る。`--tools \"\"` で組み込みツールを全部外せます。`--tools \"Read,Grep\"` のように、使うものだけ残す手もあります。\n3. MCPを切る。`--mcp-config` を渡さずに `--strict-mcp-config` を付けると、設定済みのMCPサーバーを読み込まなくなります。\n4. システムプロンプトを差し替える。`--system-prompt \"...\"` で置き換えられます。ただし、Claude Codeらしい振る舞いの指示も消えます。文章の整形や分類のような単純作業向けです。\n\nオプションの細かい仕様はバージョンで変わることがあります。手元で `claude --help` を開いて、名前を確認してから試してください。\n\n## キャッシュを味方にする\n\n荷物を減らしたら、次は「同じ荷物を安く運ぶ」番です。\n\nキャッシュは、先頭から同じ部分にだけ効きます。だから、毎回変わるもの（日時、ランダムなID、ファイルごとの内容）は、プロンプトの後ろに置きます。先頭に置くと、そこから先が全部、別物と見なされます。\n\nもう一つは間隔です。キャッシュには有効期限があり、数分ほど使われないと切れます。スクリプトで何十件も処理するなら、続けて回したほうが得です。\n\n最後に、`--max-turns` でターン数を絞るのも効きます。ツールを使うたびに会話が1往復増え、そのたびに荷物が再送されるからです。\n\n宿題は一つだけ。いま使っているスクリプトの `claude -p` に `--output-format json` を付けて、合計を一度出してみてください。数字が見えたら、半分終わったようなものです。"
    },
    {
      "condition": "3",
      "name": "文体の見本",
      "run": 3,
      "cost_usd": 0.0311,
      "text": "# `claude -p \"hi\"` だけで入力トークンが膨らむ理由と、減らし方\n\n`claude -p \"hi\"` と打つだけで、入力トークンが想像より大きい数字になることがあります。こちらが送ったのは2文字なのに。\n\n犯人は、あなたのプロンプトではありません。その前に毎回くっついてくる荷物です。\n\n## 荷物の中身\n\n`claude -p` は、一言だけ送る場合でも、次のものをまとめてモデルに渡します。\n\n- Claude Code本体のシステムプロンプト\n- 組み込みツール（Bash、Read、Edit、Grepなど）の定義\n- 接続しているMCPサーバーのツール定義\n- 作業ディレクトリの `CLAUDE.md` や、ユーザー設定の指示\n- スキルやスラッシュコマンドの一覧\n\nツールの定義は、名前、説明、引数のスキーマが全部テキストです。MCPサーバーを何本も入れていると、ここがじわじわ効いてきます。\n\nつまり「短い質問」と「短い入力」は別物です。対話モードでは気づきにくいのですが、スクリプトで何十回も回すと、この荷物が毎回乗ります。\n\n## まず測る\n\n減らす前に、今いくつなのかを見ましょう。`--output-format json` を付けると、結果と一緒に使用量が返ってきます。\n\n```bash\nclaude -p \"hi\" --output-format json | jq '.usage'\n```\n\n見るのは次の3つです。\n\n- `input_tokens`: キャッシュに乗らなかった分の入力\n- `cache_creation_input_tokens`: キャッシュに新しく書き込んだ分\n- `cache_read_input_tokens`: キャッシュから読んだ分\n\n「入力の合計」は、この3つの足し算で考えます。`input_tokens` だけ見て「少ない」と安心すると、見誤ります。コストは `total_cost_usd` にも出ます。\n\n次に、場所を変えて同じコマンドを打ってみてください。\n\n```bash\ncd ~/your-repo && claude -p \"hi\" --output-format json | jq '.usage'\nmkdir -p /tmp/empty && cd /tmp/empty && claude -p \"hi\" --output-format json | jq '.usage'\n```\n\n差が出たなら、その差が `CLAUDE.md` などプロジェクト由来の荷物です。自分の環境の数字は、自分で測るのがいちばん確かです。\n\n## 荷物を減らす4つの手\n\nどれも1つずつ足して、そのたびに測り直すのがおすすめです。何が効いたか分かります。\n\n1. 空のディレクトリで実行する。作業ディレクトリの `CLAUDE.md` を読ませる必要がない処理なら、これだけで軽くなります。\n2. ツールを絞る。`--tools \"Read,Bash\"` のように必要なものだけ渡すと、使わないツールの定義が載りません。ツールが要らない処理なら `--tools \"\"` です。なお `--allowedTools` は許可の設定なので、定義を消す目的には向きません。\n3. MCPを絞る。`--strict-mcp-config` と `--mcp-config` を組み合わせると、指定したMCPサーバーだけが使われます。\n4. 設定とシステムプロンプトを見直す。`--setting-sources` で読む設定の範囲を限定できます。`--system-prompt` で差し替えもできますが、デフォルトの行動指針も一緒に消えるので、挙動が変わらないか確かめてからにしてください。\n\nオプションはバージョンで増減します。手元で `claude --help` を見て、使えるものを確認してください。\n\n## キャッシュは「減らす」より「安くする」\n\nここまでは荷物そのものを軽くする話でした。もう1つ、荷物を安く運ぶ仕組みがプロンプトキャッシュです。\n\n毎回同じ先頭部分（システムプロンプトやツール定義）は、一度キャッシュに書き込まれると、次からは読み出しとして扱われます。読み出しは通常の入力より安く課金されます。先ほどの `cache_read_input_tokens` が大きければ、キャッシュが効いている証拠です。\n\nただしキャッシュには有効期限があり、短い間隔で呼ばないと切れます。ここから、自動化での心得が2つ出てきます。\n\n- 同じ種類の処理は、続けて流す。間が空くと、また書き込みからやり直しです。\n- 先頭部分を毎回変えない。日時やランダムなIDをプロンプトの冒頭に埋めると、そこから先がキャッシュに乗らなくなります。変わる部分は末尾に置きましょう。\n\n荷物を減らし、残った荷物はキャッシュで安くする。この二段構えです。\n\nまずは `hi` を1回、JSONで打ってみてください。数字を見ると、スクリプトの設計が少し変わります。"
    },
    {
      "condition": "3",
      "name": "文体の見本",
      "run": 4,
      "cost_usd": 0.0269,
      "text": "# 「hi」と送っただけなのに、入力トークンが大きい\n\n`claude -p \"hi\"` を試して、使用量を見て驚いた人は多いと思います。二文字しか送っていないのに、入力が数千、環境によってはそれ以上になっている。\n\n犯人はあなたのプロンプトではありません。Claude Codeが毎回、裏で一緒に送っているものです。\n\n## 何が一緒に送られているのか\n\n`claude -p` は「チャットに一言投げる」コマンドではなく、「エージェントを一回起動する」コマンドです。起動したエージェントは仕事ができる状態で待機する必要があるので、次のようなものを丸ごと抱えて出発します。\n\n- システムプロンプト（振る舞いのルール）\n- ビルトインツールの定義（ファイル読み書き、シェル実行、検索など）\n- MCPサーバーのツール定義（つないだ数だけ増える）\n- CLAUDE.mdやメモリ、スキルの説明\n- 作業ディレクトリの情報\n\n特に効いてくるのがツール定義です。ツールは名前だけでなく、使い方の説明と引数の仕様まで文章で渡されます。MCPサーバーを何個もつないでいると、挨拶一回のために大量のマニュアルを持ち歩くことになります。\n\nつまり「短い一言でも大きい」のは仕様どおりです。減らすには、持ち物を減らすしかありません。\n\n## まず測る\n\n減らす前に測りましょう。`--output-format json` を付けると、結果と一緒に使用量が返ります。\n\n```bash\nclaude -p \"hi\" --output-format json | jq '.usage, .total_cost_usd'\n```\n\n見るのはこのあたりです。\n\n- `input_tokens`: キャッシュにかからなかった入力\n- `cache_creation_input_tokens`: キャッシュに新しく書き込んだ分\n- `cache_read_input_tokens`: キャッシュから読んだ分\n- `output_tokens`: 出力\n\n入力の総量は、この3つの入力系を足したものです。`input_tokens` だけ見て「小さいな」と安心すると、実は大部分が `cache_` 側に入っていた、ということが起きます。\n\n次に、環境を変えて数字を比べます。\n\n1. 空のディレクトリで実行する\n2. いつものプロジェクトで実行する\n3. 同じコマンドをもう一度実行する\n\n1と2の差が、CLAUDE.mdやプロジェクト設定の重さです。2と3の差が、キャッシュの効き具合です。数字は環境ごとに違うので、自分の手元で出してください。\n\n## 減らす手を一つずつ試す\n\n測定コマンドに、次のオプションを一つずつ足して数字の変化を見ます。一度に全部変えると、何が効いたのか分からなくなります。使えるオプションはバージョンで変わるので、`claude --help` で確認してください。\n\n**ツールを絞る。** `--tools` で使える組み込みツールを指定できます。要約や分類のようにファイルを触らない処理なら、ほとんど要りません。\n\n**MCPを切る。** `--strict-mcp-config` を付けると、`--mcp-config` で明示したサーバーだけが使われます。何も渡さなければ、MCP由来のツール定義は載りません。普段使いのMCPが自動化スクリプトにまで付いてくるのは、意外と盲点です。\n\n**システムプロンプトを自前にする。** `--system-prompt` で置き換えられます。`--append-system-prompt` は既存の後ろに足すだけなので、減らす目的なら前者です。ただし、標準の指示がなくなる分、挙動は変わります。\n\n**設定の読み込みを絞る。** `--setting-sources` で読み込む設定の範囲を限定できます。CLAUDE.mdが大きいプロジェクトでは、ここが効くかもしれません。あわせて `--disable-slash-commands` でスキルやコマンドの分も外せます。\n\n仕上げに `--max-turns` で往復回数に上限を付けておくと、想定外に長引いて入力が積み上がる事故を防げます。\n\n## 減らせないものは、安くする\n\nどうしても残る固定部分があります。そこで効くのがプロンプトキャッシュです。同じ先頭部分を短時間にもう一度送ると、その部分は書き込みより安い「読み込み」として扱われます。\n\nここで押さえたいのは、キャッシュは先頭から一致した部分にだけ効くということです。\n\n- スクリプトから何度も呼ぶなら、間隔をあけすぎない\n- 呼び出しのたびにオプションや設定を変えない\n- 毎回変わる情報（日時やID）は、プロンプトの後ろ側に置く\n\n先ほどの「3. 同じコマンドをもう一度」で `cache_read_input_tokens` が増えていれば、効いています。増えていなければ、先頭のどこかが毎回変わっているはずです。\n\nまずは自分の環境で、空ディレクトリの `hi` を一回測ってみてください。その数字が、あなたの出発点です。"
    },
    {
      "condition": "3",
      "name": "文体の見本",
      "run": 5,
      "cost_usd": 0.0293,
      "text": "## 一言なのに、入力が大きい理由\n\n`claude -p \"hi\"` と打ちました。送ったのは2文字です。なのに入力トークンを見ると、2文字とは思えない数字が出ます。\n\n理由は単純で、送られているのはあなたの一言だけではないからです。`claude -p` は対話モードと同じ土台の上で動きます。リクエストにはだいたい次のものが一緒に入ります。\n\n- Claude Code本体のシステムプロンプト\n- Read、Bash、Editなど組み込みツールの定義\n- 接続しているMCPサーバーのツール定義\n- カレントディレクトリやホームにある CLAUDE.md\n- スキルやスラッシュコマンドの一覧\n\nつまり「一言」は、分厚い前置きの末尾に付く一行にすぎません。ツールを何十個も使えるエージェントとして起動する以上、その説明書も毎回一緒に渡す必要があるわけです。\n\n## まず測る: JSONで usage を見る\n\n減らす前に、今いくつなのかを知りましょう。`--output-format json` を付けると、結果と一緒に使用量が返ってきます。\n\n```bash\nclaude -p \"hi\" --output-format json | jq '.usage'\n```\n\n見るのは次の3つです。\n\n- `input_tokens`\n- `cache_creation_input_tokens`\n- `cache_read_input_tokens`\n\nここで落とし穴があります。プロンプトキャッシュが効くと、前置きの大部分は `input_tokens` ではなく cache 側に計上されます。`input_tokens` だけ見て「小さいな」と安心するのは早いです。3つを足して、はじめて実際に送った量になります。\n\n```bash\nclaude -p \"hi\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\n同じコマンドを2回続けて実行してみてください。1回目は creation が大きく、2回目は read に移っているはずです。同じ前置きがキャッシュから読まれた、という印です。読み出しは新規書き込みより安く扱われます。ただ、安いだけで、ゼロではありません。料金は JSON の `total_cost_usd` でも確認できます。\n\n## 減らす: 読み込むものを削る\n\n前置きの中身がわかったので、削れるところから削ります。以下のフラグはバージョンによって名前や挙動が変わることがあります。手元の `claude --help` で確認してから使ってください。\n\n```bash\nclaude -p \"hi\" --output-format json \\\n  --tools \"\" \\\n  --strict-mcp-config \\\n  --disable-slash-commands\n```\n\nそれぞれの狙いはこうです。\n\n- `--tools \"\"` は組み込みツールを無効にします。文章の整形や分類のようにツールがいらない処理なら、定義ごと消せます。\n- `--strict-mcp-config` は `--mcp-config` で指定したMCP以外を読みません。何も指定しなければ、MCPの定義は入りません。\n- `--disable-slash-commands` はスキルやコマンドの分を省きます。\n\nあとは置き場所です。CLAUDE.md は作業ディレクトリから拾われるので、自動化用の空のディレクトリで実行すれば、プロジェクトの CLAUDE.md は入りません。設定の読み込み元は `--setting-sources` で絞れます。\n\nさらに踏み込むなら `--system-prompt` で、既定のシステムプロンプトを自分のものに置き換える手もあります。ただし、既定の指示にはツールの使い方や安全面のふるまいも含まれます。ツールを使う処理で置き換えると挙動が変わりかねないので、ツールなしの単純な処理に限るのが無難です。\n\n## 試す順番\n\n一度に全部変えないでください。どれが効いたのかわからなくなります。\n\n1. 何も付けずに測る（基準値）\n2. `--tools \"\"` だけ付けて測る\n3. `--strict-mcp-config` を足して測る\n4. 空のディレクトリで実行して測る\n5. 必要なら `--system-prompt` を試す\n\n1つ変えるたびに、先ほどの `jq` で合計を出して、メモしておきます。表にすると、自分の環境で何が重かったのかが一目でわかります。MCPを何本も入れている人は、そこが最大の犯人かもしれません。CLAUDE.md を育ててきた人は、そちらかもしれません。\n\nもう一つ。キャッシュを活かしたいなら、前置きは毎回同じにしておくのが大事です。途中の文言が少し変わるだけで、そこから後ろはキャッシュに当たらなくなります。日時やランダムな値をシステムプロンプトに混ぜていないか、自分のスクリプトを見直してみてください。\n\n削れるだけ削るのが正解とは限りません。ツールが必要な処理から無理にツールを外せば、失敗して再実行になり、かえって高くつきます。測って、1つ変えて、また測る。この繰り返しが、一番確実な節約です。"
    },
    {
      "condition": "4",
      "name": "他人の記事（公式ドキュメント）",
      "run": 1,
      "cost_usd": 0.0315,
      "text": "`claude -p \"hi\"` のような一言でも、入力トークンは思ったより大きくなります。ユーザーが書いたのは数文字でも、Claude Codeが実際に送っているのはそれだけではないからです。\n\n## 一言でも入力が大きくなる理由\n\n`claude -p` は対話しないだけで、中身は通常のClaude Codeと同じエージェントです。リクエストのたびに、次のようなものがユーザーの文章の前に付きます。\n\n- Claude Code本体のシステムプロンプト\n- Bash、ファイル編集、検索などの組み込みツールの定義\n- 接続しているMCPサーバーのツール名とサーバー指示\n- プロジェクトやホームの `CLAUDE.md`\n- 設定ファイルやスキルなど、環境から読み込まれる情報\n\nつまり、入力の大半は「ツールを使えるエージェントとして動くための準備」です。MCPサーバーを増やしたり `CLAUDE.md` を育てたりするほど、一言の質問のコストも上がります。\n\n## まず自分の環境で測る\n\n減らす前に、今の数字を知ります。`--output-format json` を付けると、結果に使用量が含まれます。\n\n```bash\nclaude -p \"hi\" --output-format json | jq '.usage'\n```\n\n見るのは次の3つです。\n\n- `input_tokens`: キャッシュにかからなかった通常の入力\n- `cache_creation_input_tokens`: キャッシュに新しく書き込んだ分\n- `cache_read_input_tokens`: キャッシュから読み出した分\n\n同じコマンドを続けて2回実行して、値がどう変わるかも見てください。2回目に `cache_read_input_tokens` が増えていれば、プロンプトキャッシュが効いています。\n\n何が容量を使っているかを内訳で見たいときは、対話モードで `claude` を起動して `/context` を実行します。MCPやメモリファイルがどれだけ占めているかが分かります。\n\n## 減らす方法を一つずつ試す\n\n一度に全部変えず、1つ変えるたびに上の計測を繰り返すと、効いたものが分かります。\n\n使わないMCPサーバーを外します。自動化スクリプトに必要なサーバーだけを渡す形にできます。\n\n```bash\nclaude -p \"hi\" --strict-mcp-config --mcp-config ./mcp-min.json --output-format json\n```\n\n使うツールを絞ります。ファイル操作が要らない処理なら、組み込みツールを減らせます。\n\n```bash\nclaude -p \"hi\" --tools \"\" --output-format json\n```\n\n読み込む設定を限定します。ユーザー設定やプロジェクトの `CLAUDE.md` が不要な処理なら、`--setting-sources` で読み込み元を絞れます。\n\nモデルを軽くします。分類や整形のような単純な処理は、`--model haiku` のように小さいモデルで足ります。入力トークン数そのものは変わりませんが、単価が下がります。\n\nフラグの名前や挙動はバージョンで変わることがあります。使う前に `claude --help` で確認してください。\n\n## キャッシュを味方にする\n\n入力を減らすだけでなく、同じ入力をキャッシュに乗せ続ける考え方もあります。システムプロンプトやツール定義のような毎回同じ部分は、2回目以降、キャッシュから安く読まれます。\n\nスクリプトに組み込むときは、次の点を意識します。\n\n- 実行ごとに変わる値(日時、ランダムなID)を、プロンプトの先頭付近に入れない\n- 共通の指示を前に、毎回変わる入力を後ろに置く\n- フラグや設定をループの途中で変えない。ツール定義が変わると、前半が同じでもキャッシュが使えなくなることがある\n\nこれも計測で確かめられます。変更前後で `cache_read_input_tokens` と `cache_creation_input_tokens` を比べ、読み出しが増えて書き込みが減っていれば成功です。\n\nまずは手元で `claude -p \"hi\" --output-format json` を1回実行して、自分の環境の基準値を控えるところから始めてください。"
    },
    {
      "condition": "4",
      "name": "他人の記事（公式ドキュメント）",
      "run": 2,
      "cost_usd": 0.0267,
      "text": "## 一言でも入力トークンが大きくなる理由\n\n`claude -p \"hi\"` で送られるのは「hi」だけではありません。Claude Code は呼び出しのたびに、次のものをまとめてモデルに渡します。\n\n- 組み込みのシステムプロンプト\n- Read、Edit、Bash など組み込みツールの定義\n- ユーザーとプロジェクトの CLAUDE.md\n- 設定済みの MCP サーバーのツール名や指示\n- スキルやフックなど、設定ファイル由来の内容\n\n`-p` は画面に対話UIを出さないだけで、読み込む内容は対話モードとほぼ同じです。作業ディレクトリに大きな CLAUDE.md があったり、MCP サーバーをいくつも登録していたりすると、一言の質問でも入力は大きくなります。\n\n## まず自分の環境で測る\n\n推測で削ると効果が分かりません。`--output-format json` を付けると、結果に使用量が含まれます。\n\n```bash\nclaude -p \"hi\" --output-format json | jq '.usage, .total_cost_usd'\n```\n\n見るのは `input_tokens`、`cache_creation_input_tokens`、`cache_read_input_tokens` の3つです。実際に処理された入力の規模は、この3つを合計して考えます。\n\n同じコマンドを続けて2回実行してみてください。1回目は `cache_creation_input_tokens` が大きく、2回目は同じ内容が `cache_read_input_tokens` に移るはずです。これがプロンプトキャッシュで、前回と同じ先頭部分を再利用すると、その分は安く処理されます。\n\n次に、空のディレクトリとプロジェクトのディレクトリで同じコマンドを実行して合計を比べます。差が大きければ、CLAUDE.md や設定の影響です。対話セッションなら `/context` で内訳も確認できます。\n\n## 減らす方法を一つずつ試す\n\n1つ変えるたびに測り直し、効いたものだけ残します。以下のオプションはバージョンによって有無や挙動が違うので、先に `claude --help` で確認してください。\n\n- MCP を絞る: `--strict-mcp-config` と `--mcp-config` を組み合わせると、指定した設定ファイルのサーバーだけを使えます。自動化に不要なサーバーは外します。\n- ツールを絞る: `--tools` で使う組み込みツールを限定すると、ツール定義の分が減ります。要約や分類など、ファイル操作が要らない処理で効きます。\n- 設定の読み込みを絞る: `--setting-sources` で読み込む設定の範囲を限定できます。`--bare` のような最小構成のオプションがあれば、フックやスキル、CLAUDE.md の自動読み込みをまとめて省けます。\n- CLAUDE.md を見直す: 自動化には関係ない説明が溜まっていないか確認し、必要なら自動化専用のディレクトリを作ってそこで実行します。\n- システムプロンプトを置き換える: `--system-prompt` で指定すると既定の内容を差し替えられます。ただし Claude Code 本来の振る舞いも変わるので、用途が単純なスクリプトに限るのが無難です。\n- モデルを選ぶ: `--model` で軽いモデルを指定すると、トークン数は同じでも費用は下がります。単純な処理に大きなモデルは要りません。\n\n## キャッシュを壊さない\n\n減らす工夫をしても、呼び出しごとにオプションや読み込む内容が変わると、先頭部分が前回と一致せずキャッシュが効きません。ループで何度も `claude -p` を呼ぶなら、次の点を揃えます。\n\n- ツール、MCP、システムプロンプトの設定を毎回同じにする\n- 毎回変わる日時や ID などは、プロンプトの先頭ではなく末尾に置く\n- 続けて呼び出す（キャッシュには有効期間があり、間隔が空くと再作成になる）\n\n最後に、最初のコマンドをスクリプトに組み込み、実行のたびに使用量をログへ残しておくことをおすすめします。設定を変えた影響が数字で追えるので、どの削減が効いたかを後から確認できます。"
    },
    {
      "condition": "4",
      "name": "他人の記事（公式ドキュメント）",
      "run": 3,
      "cost_usd": 0.035,
      "text": "## 一言でも入力が大きくなる理由\n\n`claude -p \"こんにちは\"` と打っても、送られるのはその一言だけではありません。Claude Codeはリクエストのたびに、次のような固定の前置きを先頭に付けて送ります。\n\n- システムプロンプト\n- ファイル操作やシェル実行などの組み込みツールの定義\n- 作業ディレクトリにある CLAUDE.md\n- 有効なMCPサーバーのツール名や指示文\n\nあなたのプロンプトは、この末尾に載る一部にすぎません。対話モードでも同じですが、スクリプトから何十回も呼ぶと、毎回の固定分がそのまま積み重なります。\n\nこの固定分の負担を和らげるのがプロンプトキャッシュです。同じ先頭部分が続けて送られると、2回目以降は「キャッシュ読み取り」として扱われ、通常の入力より安くなります。ただしキャッシュには有効期間があり、先頭部分が少しでも変わると効きません。呼び出しの間隔が空く、呼ぶたびに CLAUDE.md やMCP設定が違う、といった状況では、毎回あらためて書き込みが発生します。\n\n## まず自分の環境で測る\n\n減らす前に、今の数字を見ます。`--output-format json` を付けると、結果と一緒に使用量が返ります。\n\n```bash\nclaude -p \"こんにちは\" --output-format json | jq '.usage'\n```\n\n見るのは次の4項目です。\n\n- `input_tokens`: キャッシュにかからなかった入力\n- `cache_creation_input_tokens`: キャッシュへの書き込み分\n- `cache_read_input_tokens`: キャッシュからの読み取り分\n- `output_tokens`: 出力\n\n`input_tokens` が小さくても安心はできません。実際に送られた入力の規模は、上の3つの入力系を足した値です。結果のJSONに `total_cost_usd` があれば、費用もあわせて確認できます。\n\n同じコマンドを続けて2回実行してみてください。1回目は `cache_creation_input_tokens` が大きく、2回目は `cache_read_input_tokens` に移るはずです。移らないなら、先頭部分が毎回変わっているか、間隔が空きすぎている可能性があります。\n\nもう一つ試す価値があるのは、場所を変えた比較です。空のディレクトリと、普段使っているプロジェクトのディレクトリで同じコマンドを実行します。差が大きければ、その分は CLAUDE.md や周辺設定が占めています。\n\n## 減らす方法を一つずつ試す\n\n効きそうなものを、変更前後で測りながら試します。フラグの正確な仕様は `claude --help` で確認してください。\n\n- 作業ディレクトリを選ぶ: CLAUDE.md が長いプロジェクトで実行すると、毎回それが入ります。自動化用の小さなディレクトリを作って、そこから呼ぶ方法があります。\n- MCPを絞る: `--mcp-config` で必要なサーバーだけを指定し、`--strict-mcp-config` を付けると、それ以外の設定を読み込みません。MCPのツール定義は既定で遅延読み込みされますが、ツール名や指示文は残るので、使わないサーバーは外すのが確実です。\n- ツールを絞る: 文章の要約や分類のようにファイルを触らない処理なら、`--tools` で使えるツールを限定すると、ツール定義の分が小さくなります。\n- 前置きを固定する: 毎回変わる内容（日時、入力データ）はプロンプトの後ろに置き、指示文などの固定部分を先頭にそろえます。キャッシュが効きやすくなります。\n- 並列で一斉に投げない: 同じ前置きの呼び出しを同時に大量に送ると、キャッシュができる前に全部が書き込みになることがあります。最初の1回が終わってから残りを流す方が、読み取りに回りやすくなります。\n- モデルを選ぶ: `--model` で軽いモデルにしても入力トークン数は変わりませんが、単価は下がります。単純な処理なら検討する価値があります。\n\n## 測って、一つ変えて、また測る\n\n進め方は単純です。ベースラインを測り、上のうち一つだけ変え、同じコマンドでもう一度測ります。複数を同時に変えると、何が効いたのか分からなくなります。\n\n対話モードで内訳を見たいときは、`/context` が使えます。何がどれだけコンテキストを占めているかが分かるので、`claude -p` で減らす対象を決める手がかりになります。\n\n数字が下がったら、その設定をスクリプトに固定します。下がらなければ元に戻して次へ進みます。この繰り返しで、自分の環境ではどこが大きいのかが見えてきます。"
    },
    {
      "condition": "4",
      "name": "他人の記事（公式ドキュメント）",
      "run": 4,
      "cost_usd": 0.0279,
      "text": "## 一言でも入力トークンが大きい理由\n\n`claude -p \"hi\"` のように短く聞いても、実際にモデルへ送られるのは、その2文字だけではありません。Claude Codeは毎回の呼び出しで、次のような内容をまとめて送っています。\n\n- Claude Code本体のシステムプロンプト\n- Bash、Read、Edit などの組み込みツールの定義\n- 接続されているMCPサーバーのツール名や説明\n- プロジェクトやホームにある CLAUDE.md の内容\n- 環境情報（作業ディレクトリ、OSなど）\n\nつまり、入力トークンの大半は、あなたが書いたプロンプトではなく、この「毎回付いてくる土台」です。対話モードなら一度送った土台はプロンプトキャッシュで安くなりますが、`claude -p` をスクリプトから何度も呼ぶと、呼び出しごとに新しいセッションが始まります。土台が大きいほど、1回ごとのコストに効いてきます。\n\n## 自分の環境で測る\n\n推測で削る前に、数字を見ます。`--output-format json` を付けると、結果と一緒に使用量が返ってきます。\n\n```bash\nclaude -p \"hi\" --output-format json | jq '.usage'\n```\n\n見るのは次の項目です。\n\n- `input_tokens`: キャッシュにかからなかった通常の入力\n- `cache_creation_input_tokens`: キャッシュへ新しく書き込んだ分\n- `cache_read_input_tokens`: キャッシュから読み出した分\n- `output_tokens`: 出力\n\n同じコマンドを続けて2回実行すると、2回目は `cache_read_input_tokens` が増えて、`cache_creation_input_tokens` が減ることがあります。土台がキャッシュに乗った印です。コストは `total_cost_usd` にも出るので、トークン数と合わせて記録しておくと比較しやすくなります。\n\n何が土台を膨らませているかは、対話モードで `/context` を実行すると内訳が見られます。MCPやCLAUDE.mdが意外に大きい、といった発見はここで得られます。\n\n## 土台を小さくする\n\n測った結果をもとに、効きそうなところから試します。以下はどれも `claude --help` でお使いのバージョンに存在するか確認してください。\n\n**使わないツールを外す。** 組み込みツールの定義も入力に含まれます。要約や分類のように読み書きが要らない処理なら、ツールを絞ります。\n\n```bash\nclaude -p \"この文章を要約して\" --tools \"\" < input.txt\n```\n\n**MCPサーバーを読み込まない。** 普段の対話用に設定したMCPが、スクリプトにも付いてきている場合があります。`--strict-mcp-config` を付け、`--mcp-config` で指定したもの以外を無視させます。指定しなければ、MCPなしで動きます。公式ドキュメントでも、`gh` や `aws` のようなCLIツールのほうがMCPより文脈を食いにくいと説明されています。\n\n**CLAUDE.md を見直す。** プロジェクトの CLAUDE.md が長いと、自動化の呼び出しすべてに乗ります。スクリプトで使わない手順は削るか、別ファイルに分けて必要なときだけ読ませます。`--setting-sources` で読み込む設定の範囲を絞る方法もあります。\n\n**システムプロンプトを差し替える。** `--system-prompt` で既定のものを置き換えられます。小さくできる反面、Claude Codeらしい振る舞いも変わるので、出力が崩れないか確認してから使います。\n\n**モデルを選ぶ。** 単純な処理にOpusは要りません。`--model sonnet` や haiku で足りるか試します。入力トークンの数は変わりませんが、単価が下がります。\n\n## 変えたら、もう一度測る\n\n1つ変えるたびに、先ほどの `jq '.usage'` を実行して差を見ます。複数をまとめて変えると、どれが効いたのか分からなくなります。\n\nおすすめの手順は次のとおりです。\n\n1. 何も変えない状態で3回実行し、数値を記録する\n2. `--tools \"\"` だけを足して3回実行する\n3. `--strict-mcp-config` を足して、さらに3回実行する\n4. 差が大きかった順に、本番のスクリプトへ取り込む\n\n1回目はキャッシュの書き込みが走りやすいので、2回目以降の値で比べます。また、設定を変えるとキャッシュの対象も変わるため、変更直後の1回目は `cache_creation_input_tokens` が増えるのが普通です。\n\nもう1つ、キャッシュを活かす工夫があります。同じ土台で何件も処理するなら、呼び出し間隔を空けすぎず、システムプロンプトやツール構成を途中で変えないことです。先頭部分が同じなら、キャッシュが効きやすくなります。\n\nまずは `--output-format json` で自分の「土台」の大きさを見てください。数字が分かれば、削る場所は自然に決まります。"
    },
    {
      "condition": "4",
      "name": "他人の記事（公式ドキュメント）",
      "run": 5,
      "cost_usd": 0.0271,
      "text": "## 「hi」だけで入力トークンが大きい理由\n\n`claude -p \"hi\"` と打つと、送られるのは「hi」の2文字だけではありません。Claude Codeは毎回、次のものをまとめてモデルに渡します。\n\n- Claude Code本体のシステムプロンプト\n- Bash、Read、Edit などの組み込みツールの定義\n- 作業ディレクトリやホームにある CLAUDE.md\n- 設定済みのMCPサーバーの情報\n- スキルやフックなどの追加設定\n\n対話モードで長く使えば会話履歴も増えますが、`-p` で一言投げた場合の入力の大半は、この固定部分です。つまり「質問が短いのにトークンが多い」のは異常ではなく、ツールと設定を持った状態で起動しているためです。\n\n固定部分はプロンプトキャッシュの対象になります。同じ内容を繰り返し送るとき、2回目以降は安いキャッシュ読み取りになります。ただし、キャッシュに乗っていてもコンテキストに入っていることに変わりはないので、中身を減らす価値はあります。\n\n## まず自分の環境で測る\n\n減らす前に、今の数字を見ます。`--output-format json` を付けると、結果と一緒に使用量が返ります。\n\n```bash\nclaude -p \"hi\" --output-format json | jq '{usage: .usage, cost: .total_cost_usd}'\n```\n\n見るのは `usage` の中の次の項目です。\n\n- `input_tokens`: キャッシュにかからなかった通常の入力\n- `cache_creation_input_tokens`: キャッシュに書き込んだ分\n- `cache_read_input_tokens`: キャッシュから読んだ分\n- `output_tokens`: 出力\n\n同じコマンドを2回続けて実行すると、1回目は `cache_creation_input_tokens` が大きく、2回目は `cache_read_input_tokens` が大きくなるはずです。これがキャッシュの動きです。比較するときは、3つの入力項目の合計を「入力の総量」として記録しておくと、あとで施策の効果を比べやすくなります。\n\nコンテキストの内訳を知りたいときは、対話モードで `/context` を実行します。何がどれだけ場所を取っているかが一覧で出るので、`-p` で減らす対象を決める手がかりになります。\n\n## 減らす方法を一つずつ試す\n\n一度に全部変えると、何が効いたか分からなくなります。1項目ずつ変えて、先ほどのコマンドで再測定してください。\n\nまず、CLAUDE.md の影響を確かめます。空のディレクトリで同じコマンドを実行し、プロジェクトで実行した場合と比べます。差が大きければ、CLAUDE.md が重いということです。\n\n```bash\nmkdir /tmp/empty && cd /tmp/empty\nclaude -p \"hi\" --output-format json | jq '.usage'\n```\n\n次に、MCPサーバーを外します。普段使うサーバーが入っていると、その分の情報が毎回載ります。`-p` の自動化では、必要なものだけを明示するのが確実です。\n\n```bash\nclaude -p \"hi\" --strict-mcp-config --mcp-config ./mcp.json --output-format json\n```\n\n`--strict-mcp-config` を付けると、`--mcp-config` で指定したもの以外は読み込まれません。空のJSONを渡せば、MCPなしで測れます。\n\nツールの絞り込みも試せます。要約や分類のように、ファイル操作が要らない処理なら、使えるツールを限定すると定義の分が減ります。`--tools` の指定方法はバージョンで違うことがあるので、`claude --help` で確認してください。同じ理由で、`--bare` のように設定の自動読み込みを省くオプションがあるかも、ヘルプで探す価値があります。\n\n最後にモデルです。単純な処理ならSonnetやHaikuで足りることが多く、`--model` で切り替えられます。これはトークン数ではなく単価に効くので、`total_cost_usd` で比べてください。\n\n## キャッシュを効かせる呼び出し方\n\nスクリプトから何度も `claude -p` を呼ぶなら、固定部分を変えないことが大切です。キャッシュは先頭から同じ内容が続く範囲で効くので、毎回変わる情報をプロンプトの前のほうに置くと、読み取りが減ります。\n\n- 変わらない指示やルールは前に置き、入力データなど毎回変わる部分は最後に置く\n- 呼び出しごとにMCPやツールの構成を変えない\n- 日時やランダムなIDを、システムプロンプトに追加する文へ入れない\n\n関連する作業は同じ構成でまとめて流し、別の用途は別の構成にします。測定の手順は変わりません。構成を変えるたびに、同じコマンドを2回実行し、1回目と2回目の `usage` を見比べてください。2回目に `cache_read_input_tokens` が増えていれば、キャッシュが効いています。\n\nまずは今日、手元のスクリプトで `--output-format json` を付けて、数字を1回記録してみてください。"
    },
    {
      "condition": "5",
      "name": "公式情報の箇条書き",
      "run": 1,
      "cost_usd": 0.0321,
      "text": "`claude -p \"こんにちは\"` のような一言でも、入力トークンは想像より大きくなります。スクリプトに組み込んで何度も呼ぶなら、この差は無視できません。ここでは理由を整理し、自分の環境で測って減らす手順を紹介します。\n\n## 一言でも入力が大きくなる理由\n\nモデルに渡されるのは、あなたが書いた一言だけではありません。Claude Codeは、CLAUDE.md、MCPサーバー、skillsを自動で読み込みます。システムプロンプトもそこに加わります。トークンの消費量は、モデルが処理する文脈の大きさに比例して増えるので、これらがすべて入力の分量になります。\n\nMCPサーバーのツール定義は、既定では遅延読み込みです。文脈に入るのはツール名とサーバーの説明だけで、中身は実際に使うまで入りません。それでも、サーバーを何本も登録していれば、名前と説明だけで相応の量になります。\n\nシステムプロンプトのような繰り返し出てくる内容は、プロンプトキャッシュで割引されます。ただしこれは単価が下がる仕組みで、文脈そのものが小さくなるわけではありません。まず中身を小さくするのが先です。\n\n## 自分の環境で測る\n\n何が容量を食っているかは、対話モードの `/context` で見えます。`claude -p` を実行するのと同じディレクトリで `claude` を起動し、`/context` を実行してください。CLAUDE.md、MCPサーバー、skillsのどれが大きいかがわかります。\n\n実際の呼び出しの数字は、JSON形式の出力で確認できます。\n\n```sh\nclaude -p \"こんにちは\" --output-format json\n```\n\n出力に含まれる `usage` の項目に、入力トークン数のほか、キャッシュの書き込みと読み取りの数が出ます。項目名はバージョンで変わることがあるので、手元の出力を見てください。\n\n比較用に、空のディレクトリでも同じコマンドを実行してみてください。プロジェクトのCLAUDE.mdが読まれない状態との差が、プロジェクト由来の分量の目安になります。ただしユーザー設定のMCPサーバーやskillsは空のディレクトリでも読み込まれるので、差が出ない分もあります。\n\n## 減らす\n\n測って大きかったところから順に手を付けます。\n\n- 使っていないMCPサーバーを、`/mcp` で確認して無効にします。遅延読み込みでも、名前と説明は毎回入ります。\n- CLAUDE.md を見直します。その自動化では使わない指示が入っていたら、削るか別ファイルに分けます。\n- 使っていないskillsも同じ要領で整理します。\n- 簡単な作業はSonnet、複雑な判断にはOpusというように、モデルを使い分けます。`--model` で指定できます。トークン数は変わりませんが、コストは下がります。\n\n同じ会話を続けて何度も呼ぶ場合は、履歴も文脈に乗ります。会話は上限に近づくと自動で要約されますが、そこまで待たずに、独立した作業は新しい呼び出しに分けるほうが、入力は小さく保てます。\n\n## 試す順番\n\n1. 空のディレクトリで `--output-format json` を付けて実行し、基準の入力トークン数を控える\n2. 実際に使うディレクトリで同じ実行をして、差を見る\n3. `/context` で大きい項目を探す\n4. 一つだけ減らして、もう一度測る\n\n一度に複数を変えると、どれが効いたのかわからなくなります。一つずつ変えて、そのつど数字を残してください。"
    },
    {
      "condition": "5",
      "name": "公式情報の箇条書き",
      "run": 2,
      "cost_usd": 0.0367,
      "text": "`claude -p \"こんにちは\"` のような一言でも、入力トークンを見ると思ったより大きな数字が出ます。入力はあなたが書いた一言だけではないからです。\n\n## 一言の裏で読み込まれているもの\n\nトークンの消費量は、モデルが処理する文脈(コンテキスト)の大きさに比例して増えます。`claude -p` は、プロンプトを送る前に、文脈へ次のようなものを入れます。\n\n- システムプロンプト\n- CLAUDE.md\n- MCPサーバーの情報\n- skills\n\nこのうち CLAUDE.md、MCPサーバー、skills は自動で読み込まれます。同じ一言でも、実行するディレクトリや設定によって入力の大きさが変わるのはこのためです。\n\nMCPサーバーのツール定義は、既定では遅延読み込みです。文脈に入るのはツール名とサーバーの説明だけで、中身は実際に使うまで入りません。ただ、サーバーを多く登録していれば、その名前と説明は毎回入ります。\n\nもうひとつ、プロンプトキャッシュも知っておくと数字が読みやすくなります。システムプロンプトのように繰り返し出てくる内容は、キャッシュによって割引されます。入力トークンが大きく見えても、その一部は割引の対象になっているので、トークン数と費用は単純には比例しません。\n\n## 自分の環境で測る\n\nまず、何が容量を使っているかを見ます。スクリプトを実行するのと同じディレクトリで `claude` を対話モードで起動し、`/context` を実行してください。文脈の何が容量を食っているかが一覧で見えます。\n\n次に、`claude -p` 自体の数字を取ります。\n\n```bash\nclaude -p \"hi\" --output-format json | jq '.usage'\n```\n\n出力には、入力トークン、キャッシュに書き込まれた分、キャッシュから読まれた分といった項目が含まれます。項目名はバージョンで変わることがあるので、手元の出力で確認してください。キャッシュから読まれた分が多ければ、大きく見える入力の多くは割引されています。\n\n測るときは、同じ短い入力(上の `hi` など)を使い、変更は一度に一つだけにします。基準値を最初に控えておけば、あとで何が効いたかが分かります。\n\n## 減らす\n\n`/context` で大きかったものから順に手を付けます。\n\n1. 使っていないMCPサーバーを無効にする。対話モードで `/mcp` を実行すると一覧を確認できます。スクリプト専用に必要なサーバーだけを使いたいなら、`--mcp-config` と `--strict-mcp-config` の組み合わせがあります。細かい挙動は `claude --help` で確認してください。\n2. CLAUDE.md を小さくする。自動で読み込まれるので、対話で作業するための長い指示は、自動化では余計な入力になります。自動化専用のディレクトリを作り、そこには最小限の CLAUDE.md だけを置く方法があります。上位のディレクトリやホームにある設定も読まれることがあるので、`/context` で実際に何が入っているかを見てください。\n3. 使わない skills を整理する。これも自動で読み込まれるため、CLAUDE.md と同じ考え方で見直せます。\n4. 作業に合うモデルを選ぶ。簡単な作業は Sonnet、複雑な判断には Opus と使い分けると安くなります。`--model sonnet` のように指定できます。これは入力トークンの数を減らすものではなく、同じトークンにかかる費用を下げる手段です。\n5. 会話を引き継がない。会話履歴は上限に近づくと自動で要約されますが、要約されるまでは文脈に乗り続けます。`--continue` や `--resume` で前の会話を引き継ぐと、その分が入力に加わります。毎回独立した処理なら、引き継がないほうが入力は小さく保てます。\n\n## 試す順番\n\n最初に `/context` で内訳を見て、次に `claude -p \"hi\" --output-format json` で基準値を控えます。そのうえで、MCP、CLAUDE.md、skills のうち大きいものを一つ減らし、同じコマンドをもう一度実行して差を見ます。これを繰り返せば、自分の環境で何が効いたのかを数字で確認できます。\n\n一言で大きく見える入力は、多くの場合、設定を自動で読み込んだ結果です。中身を知り、不要なものを外し、数字で確かめるところまでは、すぐに試せます。"
    },
    {
      "condition": "5",
      "name": "公式情報の箇条書き",
      "run": 3,
      "cost_usd": 0.0263,
      "text": "## 一言を投げただけで入力トークンが大きくなる理由\n\n`claude -p \"こんにちは\"` のように短い質問でも、モデルに渡される入力はその一言だけではありません。トークンの消費量は、モデルが処理する文脈の大きさに比例して増えます。そしてこの文脈には、自分で書いたプロンプトの外側にあるものが含まれています。\n\n代表的なのは、システムプロンプト、CLAUDE.md、MCPサーバー、skillsです。これらは自動で読み込まれるので、自分では何も足していないつもりでも、実行のたびに文脈へ入ります。作業ディレクトリに長いCLAUDE.mdがあったり、MCPサーバーをいくつも登録していたりすると、一言の質問でもその分が上乗せされます。\n\nMCPサーバーのツール定義は、既定では遅延読み込みです。ツール名とサーバーの説明だけが文脈に入り、実際に使うまで中身は入りません。それでもサーバーの数が増えれば、名前と説明の分は積み上がります。\n\n## 自分の環境で測る\n\nまず、実際にどれだけ入力されているかを見ます。`--output-format json` を付けると、結果と一緒に使用量が返ってきます。\n\n```bash\nclaude -p \"こんにちは\" --output-format json | jq '.usage'\n```\n\n見るのは次の3つです。名前は、お使いのバージョンの出力で確認してください。\n\n- `input_tokens`: キャッシュされなかった入力\n- `cache_creation_input_tokens`: キャッシュに書き込まれた入力\n- `cache_read_input_tokens`: キャッシュから読み出された入力\n\n同じコマンドを続けて2回実行して、値を比べてみてください。システムプロンプトのように繰り返し出てくる内容はプロンプトキャッシュで割引されるので、2回目は読み出しの欄に分類が移るはずです。自動化に組み込むなら、この「2回目以降」の値が実際の運用に近くなります。\n\n内訳を知りたいときは、同じディレクトリで対話モードの `claude` を起動し、`/context` を実行します。文脈の何が容量を食っているかが見えます。CLAUDE.mdが大きいのか、MCPなのか、といった当たりをここで付けられます。\n\nもう一つ試す価値があるのは、CLAUDE.mdも設定もない空のディレクトリで同じ `claude -p` を実行して比べることです。差分が、そのプロジェクト固有の設定が持ち込んでいる分です。\n\n## 減らす方法を順に試す\n\n測れたら、効きそうなところから一つずつ変えて、そのたびに同じコマンドで測り直します。一度に複数を変えると、何が効いたのか分からなくなります。\n\n1. 使っていないMCPサーバーを無効にする。対話モードで `/mcp` を実行して一覧を確認し、スクリプトで使わないものを外します。\n2. CLAUDE.mdを見直す。自動で毎回読み込まれるので、その作業に関係ない説明が混ざっていないか確認します。自動化専用の短いCLAUDE.mdを置いた別ディレクトリから実行する、という分け方もあります。\n3. モデルを使い分ける。簡単な作業はSonnet、複雑な判断にはOpus、というように分けると安くなります。`claude -p \"...\" --model sonnet` のように指定できます。分類や整形のような定型の処理は、軽いモデルで足りることが多いです。\n4. 長い会話に頼らない。会話履歴は上限に近づくと自動で要約されますが、文脈が大きいほど消費も増えます。スクリプトからの呼び出しは、1回ごとに用件を完結させる設計のほうが読みやすく、測りやすくなります。\n\n## キャッシュを味方にする\n\nプロンプトキャッシュで割引されるのは、繰り返し出てくる内容です。つまり、毎回同じ前置き(システムプロンプトや、変わらないCLAUDE.mdの内容)を持つ呼び出しほど、恩恵を受けやすくなります。逆に、実行のたびにCLAUDE.mdを書き換えたり、MCPサーバーの構成を変えたりすると、繰り返しの部分が崩れます。\n\n自動化では、変わらない設定は固定し、変わる部分(今回処理したい入力)だけを `-p` の引数や標準入力で渡す形にしておくと、測定も安定します。\n\n最後に手順をまとめます。`--output-format json` で `usage` を見て、`/context` で内訳を調べ、`/mcp` とCLAUDE.mdを整理し、もう一度測ります。数字の変化が自分の環境での答えになるので、まず一度、空のディレクトリと普段のプロジェクトで測り比べてみてください。"
    },
    {
      "condition": "5",
      "name": "公式情報の箇条書き",
      "run": 4,
      "cost_usd": 0.0278,
      "text": "# `claude -p` は一言でも入力トークンが大きい。理由と、測って減らす手順\n\n`claude -p \"こんにちは\"` のように短い一言を投げただけなのに、入力トークンが思ったより大きい。スクリプトに組み込み始めると、この点に気づく人は多いはずです。この記事では理由を押さえたうえで、自分の環境で測って減らすところまで試します。\n\n## 一言なのに入力が大きくなる理由\n\nモデルに渡るのは、あなたの一言だけではありません。Claude Codeは起動時に、システムプロンプトに加えて、CLAUDE.md、MCPサーバー、skillsを自動で読み込み、文脈に入れます。トークンの消費量は、モデルが処理する文脈の大きさに比例して増えます。この土台が大きければ、質問が一言でも入力は大きくなります。\n\nMCPサーバーのツール定義は、既定では遅延読み込みです。文脈に入るのはツール名とサーバーの説明だけで、中身は実際に使うまで入りません。ただ、サーバーをたくさん登録していれば、その説明は毎回入ります。\n\nシステムプロンプトのように毎回繰り返し出てくる内容は、プロンプトキャッシュで割引されます。そのため、入力が大きいこと自体より、何が大きいのかを知るほうが先です。\n\n## まず測る\n\n次のコマンドで、結果をJSONで受け取ります。\n\n```sh\nclaude -p \"こんにちは\" --output-format json\n```\n\n出力の中の `usage` に、入力トークンの数が入っています。通常の入力、キャッシュへの書き込み、キャッシュからの読み取りが別々の項目で出ます。項目名はバージョンで変わることがあるので、手元の出力で確認してください。同じコマンドを続けて2回実行し、2回目でキャッシュ読み取りの項目が増えるかも見てみましょう。\n\n内訳を知りたいときは、同じディレクトリで対話モードの `claude` を起動し、`/context` を実行します。文脈の何が容量を食っているかが見えます。CLAUDE.mdなのか、MCPなのか、skillsなのか。ここで見えたものが、次の節で削る対象です。\n\n## 減らす\n\n`/context` で大きかったものから順に手を付けます。\n\n1. CLAUDE.md。自動で読み込まれるので、長いほど毎回の入力が増えます。自動化用の作業ディレクトリを別に作り、そこには短い CLAUDE.md だけ置く方法があります。\n2. MCPサーバー。`/mcp` で一覧を確認し、使っていないものは無効にします。\n3. 会話履歴。履歴は上限に近づくと自動で要約されますが、それまでは文脈に積み上がります。無関係な作業は同じ会話で続けず、別の呼び出しに分けると文脈が小さく保てます。\n4. モデル。トークン数そのものは減りませんが、簡単な作業はSonnet、複雑な判断にはOpus、と使い分けると安くなります。`--model` オプションで指定できます。\n\n## 一度に一つだけ変える\n\n変更は一つずつ行い、そのたびに同じ一言で測り直してください。複数をまとめて変えると、どれが効いたのかわからなくなります。\n\n手順はこうです。\n\n1. `--output-format json` で現在の入力トークンを記録する\n2. `/context` で大きい項目を見つける\n3. その項目を一つだけ減らす\n4. もう一度測って、差を確かめる\n\nこれを繰り返せば、自分のスクリプトに合った設定が見つかります。"
    },
    {
      "condition": "5",
      "name": "公式情報の箇条書き",
      "run": 5,
      "cost_usd": 0.0267,
      "text": "## 一言でも入力が大きくなる理由\n\n`claude -p \"こんにちは\"` のように短く投げても、モデルに届く入力は「こんにちは」だけではありません。Claude Codeは、システムプロンプトやツール定義に加えて、CLAUDE.md、MCPサーバー、skillsを自動で読み込み、それらをまとめて文脈に入れます。トークンの消費量は、モデルが処理する文脈の大きさに比例して増えます。つまり、あなたが書いた一言ではなく、毎回自動で付いてくる土台の大きさが入力トークンの下限を決めています。\n\n対話モードなら会話が続くたびに履歴が積み上がり、上限に近づくと自動で要約(コンパクション)されます。一方 `claude -p` は一回きりの呼び出しが多いので、履歴よりも、この土台の部分が目立ちます。cronやCIで何度も呼ぶ使い方では、その土台を毎回払うことになります。\n\nただし、繰り返し出てくるシステムプロンプトのような内容はプロンプトキャッシュで割引されます。入力トークンの数が大きく見えても、すべてが定価で課金されるわけではありません。測るときは、この点を分けて見る必要があります。\n\n## まず自分の環境で測る\n\n減らす前に、何がどれだけ入っているかを見ます。\n\n一つ目は、対話モードで `/context` を実行する方法です。文脈の何が容量を食っているかが見えます。`claude -p` を使う予定のディレクトリで `claude` を起動して実行すると、スクリプトから呼んだときとほぼ同じ土台を確認できます。CLAUDE.mdが大きいのか、MCPサーバーが多いのか、skillsなのかが分かれば、手を入れる場所が決まります。\n\n二つ目は、`claude -p` の出力そのものを見る方法です。\n\n```bash\nclaude -p \"ok と返して\" --output-format json\n```\n\nJSON出力にはトークン使用量(usage)が含まれます。通常の入力、キャッシュへの書き込み、キャッシュからの読み出しが別々の項目で出るはずです。フィールド名はバージョンで変わることがあるので、自分の出力で確認してください。\n\n同じコマンドを二回続けて実行し、比べてみてください。一回目はキャッシュに書き込まれ、二回目は読み出しに回る分が増えるかもしれません。この差を見ると、キャッシュがどの程度効いているかが分かります。\n\n## 減らす方法を順に試す\n\n測定の手順が決まったら、一つずつ変えて、そのたびに同じコマンドで測り直します。一度に複数を変えると、どれが効いたのか分からなくなります。\n\nMCPサーバーを見直します。ツール定義は既定で遅延読み込みになっており、ツール名とサーバーの説明だけが文脈に入ります。実際に使うまで中身は入りません。それでも、サーバーが増えればその分の名前と説明が積み上がります。`/mcp` で一覧を確認し、使っていないサーバーは無効にします。\n\nCLAUDE.mdとskillsを見直します。これらは自動で読み込まれるので、全体を見る必要がない細かい手順や長い説明が入っていれば、削るか分けることを検討します。スクリプト専用の作業なら、そのスクリプト用のディレクトリを作り、必要最小限の設定だけ置くのも手です。\n\n比較用に、何も置いていない空のディレクトリで同じ `claude -p` を実行してみてください。そこで出た値が、自分の設定を除いた土台の大きさの目安になります。普段のディレクトリとの差が、自分の設定が増やしている分です。\n\nモデルも使い分けます。簡単な作業はSonnet、複雑な判断にはOpusというように振り分けると安くなります。`claude -p` に `--model` を付ければ、スクリプトの用途ごとに指定できます。分類や整形のような単純な処理に重いモデルを使い続けていないか、見直す価値があります。\n\n## 結果の見方\n\n測定結果を見るときは、入力トークンの合計だけで判断しないでください。キャッシュから読み出された分は割引の対象になるため、合計が大きくても負担が小さい場合があります。逆に、呼び出しのたびに内容が変わる部分があると、キャッシュが効きにくくなります。\n\n次の順で進めると、迷いにくくなります。\n\n1. `/context` で何が大きいかを確認する\n2. `--output-format json` で、いまの入力トークンとキャッシュの内訳を記録する\n3. MCP、CLAUDE.md、skillsのどれか一つを変える\n4. 同じコマンドを二回実行して、記録と比べる\n5. 作業の難しさに合わせてモデルを選び直す\n\n数字を記録しておけば、次に設定を足したときに「どれだけ増えたか」も分かります。自動化は動かし続けるものなので、最初に一度測っておくことが、あとで効いてきます。"
    },
    {
      "condition": "6",
      "name": "自分のメモ",
      "run": 1,
      "cost_usd": 0.0306,
      "text": "## 「こんにちは」だけで2万トークン\n\n`claude -p` に「こんにちは。1語で返事して」と投げるだけで、私の環境では入力トークンが合計20,404になりました。3回測って3回とも同じ数字です。\n\n1語の挨拶がそんなに大きいはずはなく、中身の大半は、Claude Codeが毎回付ける前置きです。システムプロンプト、ツールの定義、MCPの情報、設定ファイルの内容、skillsの一覧などが、ユーザーの入力の前に並びます。対話で使っているぶんには気になりませんが、スクリプトから何十回も呼ぶ場面では、この前置きが毎回付いてきます。\n\nここから、実測した数字をもとに、前置きの中身と減らし方を順に見ていきます。\n\n## まず自分の環境で測る\n\n減らす前に、自分の環境での数字を知る必要があります。JSON形式で出力させると、`usage` に入力トークンが入っています。\n\n```bash\nclaude -p \"こんにちは。1語で返事して\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\n3つを足しているのには理由があります。`input_tokens` だけを見ると、2や3といった小さい数字しか出ません。前置きの大部分はキャッシュ側の `cache_creation_input_tokens` と `cache_read_input_tokens` に入るので、3つの合計を取らないと全体が見えません。\n\n費用は同じJSONの `total_cost_usd` にあります。私の環境では、既定の1回目が0.039ドル、2回目と3回目が0.005ドルでした。同じ前置きがプロンプトキャッシュに乗ると、費用は約8分の1になります。トークン数は同じでも、キャッシュが効くかどうかで請求額は大きく変わります。\n\n## 何を切ると、どれだけ減るか\n\n次のオプションを1つずつ付けて、3回ずつ測りました。入力は毎回同じです。環境は、Claude Code 2.1.291、モデルは claude-sonnet-5-5、空のフォルダです。\n\n| 設定 | 合計入力トークン |\n| --- | --- |\n| 何も付けない | 20,404 |\n| `--strict-mcp-config`(設定にあるMCPを読まない) | 18,711 |\n| `--setting-sources \"\"`(ユーザー設定・プロジェクト設定を読まない) | 17,078 |\n| `--disable-slash-commands`(skillsとスラッシュコマンドを切る) | 18,786と20,479 |\n| `--tools \"\"`(ツールを全部切る) | 2,184 |\n| tools・MCP・設定・スラッシュを全部切る | 2,011 |\n| 全部切って `--system-prompt \"You are a helpful assistant.\"` | 584 |\n\n一番効いたのは `--tools \"\"` です。MCPを切っても減るのは約1,700、設定を切っても約3,300です。それに対してツールを切ると約1万8千トークン減るので、ツール定義そのものがそれだけの大きさだとわかります。\n\n最後の584は、Claude Code標準のシステムプロンプトを自分の一行に置き換えた結果です。2,011との差から、標準のシステムプロンプトは約1,400トークン分あったことになります。\n\nばらつきも出ました。`--disable-slash-commands` は18,786と20,479に割れ、`--tools \"\"` も3回中1回だけ5,613になりました。理由は私にも分かっていません。1回の測定で判断せず、数回測って並べて見てください。\n\n## 切ると失うものと、試す順番\n\nツールを切ると、Claudeはファイルを読むことも書くこともできなくなります。使えるのは、記事を書かせる、文章を分類させる、といった、渡した文字列だけで完結する用途です。コードを読ませて直させるような使い方では、ツールを残す必要があります。\n\n試す順番としては、次のやり方が楽だと思います。\n\n1. 上の `jq` のコマンドで、既定の合計を測る。\n2. 用途がテキスト処理だけなら、`--tools \"\"` を付けて測り直す。\n3. 減り方を見ながら、`--strict-mcp-config`、`--setting-sources \"\"`、`--system-prompt` を足していく。\n4. 各設定で3回ずつ測り、`total_cost_usd` も見て、キャッシュが効いているか確かめる。\n\n私の環境はMCPやskillsが多いので、この表の数字はそのまま当てはまらないはずです。MCPを入れていない人なら、MCPを切っても差は小さいでしょう。どこに重さがあるかは環境ごとに違うので、自分のマシンで一度測るのが早い方法です。"
    },
    {
      "condition": "6",
      "name": "自分のメモ",
      "run": 2,
      "cost_usd": 0.0265,
      "text": "# `claude -p` は「こんにちは」だけで入力トークンが2万になる\n\n`claude -p` に「こんにちは。1語で返事して」と投げて、入力トークンを数えてみました。結果は20,404トークンでした。質問は十数文字なのに、残りは Claude Code が毎回自動で付ける前置きです。\n\nこの記事では、前置きの中身を切り分けて測った結果と、自分の環境で同じ測定をする手順を紹介します。環境は Mac、モデルは claude-sonnet-5-5、Claude Code 2.1.291、空のフォルダで実行しています。\n\n## 入力トークンの数え方\n\nJSON出力の `usage` には入力に関する項目が3つあります。\n\n- `input_tokens`\n- `cache_creation_input_tokens`\n- `cache_read_input_tokens`\n\n私の環境では `input_tokens` は2や3としか出ませんでした。残りはキャッシュ側に入るためです。全体を知るには3つを足す必要があります。\n\n```bash\nclaude -p \"こんにちは。1語で返事して\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\n`jq` がなければ、JSONをそのまま見て手で足しても構いません。設定ごとに3回ずつ実行して、値が安定しているかも確認してください。\n\n費用は `total_cost_usd` に出ます。何も付けない既定の実行では、1回目が0.039ドル、2回目と3回目が0.005ドルでした。同じ前置きがキャッシュに乗ると、費用は約8分の1になります。つまり毎回2万トークンを全額払っているわけではありません。ただ、キャッシュに乗る前の1回目は高く、前置きが大きいほどその差も大きくなります。\n\n## 何を切ると減るか\n\nオプションを一つずつ付けて、合計入力トークンを測りました。\n\n| 設定 | 合計入力トークン |\n|---|---|\n| 何も付けない(既定) | 20,404 |\n| `--strict-mcp-config`(設定にあるMCPを読まない) | 18,711 |\n| `--setting-sources \"\"`(ユーザー設定・プロジェクト設定を読まない) | 17,078 |\n| `--disable-slash-commands`(skillsとスラッシュコマンドを切る) | 18,786と20,479にばらついた |\n| `--tools \"\"`(ツールを全部切る) | 2,184 |\n| tools・MCP・設定・スラッシュを全部切る | 2,011 |\n| 全部切って `--system-prompt \"You are a helpful assistant.\"` を渡す | 584 |\n\n一番効いたのはツールを切ることでした。MCPを切っても減るのは約1,700、設定を切っても約3,300です。一方、`--tools \"\"` で約18,200減っています。ツール定義そのものが約1万8千トークンあるということです。\n\n最後の584は、Claude Code 標準のシステムプロンプトを自分の一行に置き換えた結果です。2,011から584を引くと、標準のシステムプロンプトは約1,400トークン分あったことになります。\n\n測定で引っかかった点が2つあります。`--tools \"\"` は3回中2回が2,184でしたが、1回だけ5,613になりました。理由は分かっていません。`--disable-slash-commands` も値が揃いませんでした。この2つは一度測って判断せず、複数回測ってください。\n\nまた、私の環境はMCPやskillsが多めです。MCPや設定の削減量は人によって違うはずです。\n\n## 切ったときに失うもの\n\nツールを切ると、Claude はファイルを読むことも書くこともできなくなります。コマンドも実行できません。使えるのは次のような用途です。\n\n- 記事や文章を書かせる\n- 入力テキストを分類する\n- 要約や変換をさせる\n\nファイル操作が必要なスクリプトでは `--tools \"\"` は使えません。その場合は MCP と設定だけ切る手もありますが、減るのは合わせて数千トークンです。\n\nシステムプロンプトの置き換えも同じで、Claude Code 本来の振る舞いの指示が消えます。短い一行で足りる単発の作業なら問題になりにくいですが、エージェントとして動かす用途には向きません。\n\n## 自分の環境で試す手順\n\n1. 既定のまま3回測ります。値が揃うかを確認します。\n2. `--strict-mcp-config`、`--setting-sources \"\"`、`--tools \"\"` を一つずつ付けて、それぞれ3回測ります。どれが自分の環境で重いかが分かります。\n3. 用途に必要なものだけを残して、切れるものを組み合わせます。\n\n全部切った場合のコマンドは次のとおりです。\n\n```bash\nclaude -p \"こんにちは。1語で返事して\" \\\n  --tools \"\" \\\n  --strict-mcp-config \\\n  --setting-sources \"\" \\\n  --disable-slash-commands \\\n  --system-prompt \"You are a helpful assistant.\" \\\n  --output-format json\n```\n\n私の環境ではこれで584トークンまで下がりました。20,404からの変化は大きいですが、この値は私のMCPやskillsの量に左右されます。あなたの環境で何が重いのかは、測らないと分かりません。まず既定の1回を測るところから始めてください。"
    },
    {
      "condition": "6",
      "name": "自分のメモ",
      "run": 3,
      "cost_usd": 0.0263,
      "text": "# `claude -p` に「こんにちは」と送るだけで入力が2万トークンになる理由と、減らし方\n\n`claude -p` をスクリプトに組み込むとき、入力は短い一言で済むと思いがちです。私もそうでした。ところが空のフォルダで「こんにちは。1語で返事して」と送っただけで、入力トークンは合計20,404になりました。3回測って3回とも同じ値です。\n\nこの記事では、自分の環境で入力トークンを測る方法と、どの設定がどれだけ効くかを、私のMacで測った結果と一緒に紹介します。環境は Claude Code 2.1.291、モデルは claude-sonnet-5-5 です。\n\n## 入力トークンは3つを足さないと見えない\n\nJSON出力の `usage` には、入力に関する数字が3つあります。\n\n- `input_tokens`\n- `cache_creation_input_tokens`\n- `cache_read_input_tokens`\n\n`input_tokens` だけ見ると、2とか3しか出ません。残りはキャッシュ側に入るので、全体を知るには3つを足す必要があります。\n\n```bash\nclaude -p \"こんにちは。1語で返事して\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\n費用は同じJSONの `total_cost_usd` に入っています。同じコマンドを3回続けて実行すると、キャッシュの効き方も見えます。私の環境では、1回目が0.039ドル、2回目と3回目が0.005ドルでした。毎回送られる同じ前置きがキャッシュに乗ると、費用は約8分の1になりました。つまり、前置きが大きいこと自体は、2回目以降の費用ではそれほど痛くありません。ただ、トークン数は減らないので、1回目の費用や、キャッシュが切れたあとの実行では効いてきます。\n\n## 何を切るとどれだけ減ったか\n\n同じ入力を、設定を変えて3回ずつ測りました。\n\n| 設定 | 合計入力トークン |\n|---|---|\n| 何も付けない | 20,404 |\n| `--strict-mcp-config`(設定にあるMCPを読まない) | 18,711 |\n| `--setting-sources \"\"`(ユーザー設定・プロジェクト設定を読まない) | 17,078 |\n| `--disable-slash-commands`(skillsとスラッシュコマンドを切る) | 18,786と20,479にばらついた |\n| `--tools \"\"`(ツールを全部切る) | 2,184 |\n| tools・MCP・設定・スラッシュを全部切る | 2,011 |\n| 全部切って `--system-prompt \"You are a helpful assistant.\"` を渡す | 584 |\n\n一番効いたのはツールを切ることでした。MCPを切っても減るのは約1,700、設定を切っても約3,300です。これに対して `--tools \"\"` では20,404が2,184まで下がります。差し引きすると、ツール定義だけで約1万8千トークンあることになります。\n\nもう一つ分かったことがあります。全部切った2,011から584まで下がったのは、Claude Code標準のシステムプロンプトを自分の一行に置き換えたからです。標準のシステムプロンプトは約1,400トークン分あったことになります。\n\n測定でつまずいた点も書いておきます。`--tools \"\"` は3回中2回が2,184でしたが、1回だけ5,613になりました。理由は分かっていません。`--disable-slash-commands` も値がばらつきました。この2つは1回測って判断せず、数回測って様子を見たほうが安全です。\n\n## 切る前に確認すること\n\nツールを切ると、Claudeはファイルを読むことも書くこともできなくなります。向いているのは、文章を書かせるだけ、分類させるだけ、といった用途です。コードを編集させたい処理で `--tools \"\"` を付けても、目的は果たせません。\n\nまた、私の環境はMCPやskillsが多いほうです。MCPを切って約1,700、設定を切って約3,300という数字は、環境が違えば変わるはずです。ツール定義の約1万8千トークンも、私の環境での値として読んでください。\n\n試す順番は次のとおりです。\n\n1. 上の `jq` のコマンドで、何も付けない状態の合計を測る\n2. 用途にツールが要らないなら、`--tools \"\"` を足して測り直す\n3. 残りを減らしたければ、`--strict-mcp-config`、`--setting-sources \"\"`、`--disable-slash-commands` を足して、1つずつ差を見る\n4. 最後に `--system-prompt` で自分の一行に置き換えて測る\n\n足す設定を1つずつ変えて、そのたびに3回測ると、どれが自分の環境で効いているかが分かります。私の数字は出発点にすぎないので、手元で測った値を基準にしてください。"
    },
    {
      "condition": "6",
      "name": "自分のメモ",
      "run": 4,
      "cost_usd": 0.0264,
      "text": "# claude -p は「こんにちは」だけで約2万トークンを入力する\n\n`claude -p` に「こんにちは。1語で返事して」と投げるだけで、入力トークンは約2万になります。自分の書いた文は10文字ほどなので、残りは Claude Code が毎回自動で付けている前置きです。筆者のMacで測った結果をもとに、中身と減らし方、測り方を書きます。\n\n測定条件は、Claude Code 2.1.291、モデルは claude-sonnet-5-5、空のフォルダで実行、各設定3回ずつです。\n\n## 入力トークンの正体\n\n前置きの中身は主に次のものです。\n\n- ツール定義(ファイルを読む、コマンドを実行する、など)\n- 設定にあるMCPサーバーの情報\n- ユーザー設定・プロジェクト設定\n- skillsとスラッシュコマンド\n- Claude Code標準のシステムプロンプト\n\n対話モードでは便利な機能ですが、スクリプトから一言だけ投げる用途では、使わない機能の説明を毎回送っていることになります。\n\n## 自分の環境で測る\n\n注意点が1つあります。JSON出力の usage にある `input_tokens` は、2とか3としか出ません。残りはキャッシュ側に入るためです。`input_tokens`、`cache_creation_input_tokens`、`cache_read_input_tokens` の3つを足して初めて全体が見えます。\n\n```bash\nclaude -p \"こんにちは。1語で返事して\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\n費用は同じJSONの `total_cost_usd` にあります。設定を変えるたびに、同じ入力で数回測って比べてください。\n\n## 切ったら何が減ったか\n\n筆者の環境での合計入力トークンです。\n\n| 設定 | 合計入力トークン |\n|---|---|\n| 何も付けない(既定) | 20,404 |\n| `--strict-mcp-config`(設定のMCPを読まない) | 18,711 |\n| `--setting-sources \"\"`(ユーザー・プロジェクト設定を読まない) | 17,078 |\n| `--disable-slash-commands`(skillsとスラッシュコマンドを切る) | 18,786と20,479にばらついた |\n| `--tools \"\"`(ツールを全部切る) | 2,184 |\n| tools・MCP・設定・スラッシュを全部切る | 2,011 |\n| 全部切り、さらに `--system-prompt \"You are a helpful assistant.\"` | 584 |\n\n一番効いたのはツールを切ることで、20,404から2,184まで下がりました。MCPを切っても約1,700、設定を切っても約3,300しか減りません。差し引きすると、ツール定義だけで約1万8千トークンあることになります。\n\n最後の584は、標準のシステムプロンプトを自分の一行に置き換えた結果です。2,011から584への差なので、標準のシステムプロンプトは約1,400トークン分ありました。全部を組み合わせると次のコマンドになります。\n\n```bash\nclaude -p \"こんにちは。1語で返事して\" \\\n  --tools \"\" --strict-mcp-config --setting-sources \"\" \\\n  --disable-slash-commands \\\n  --system-prompt \"You are a helpful assistant.\" \\\n  --output-format json\n```\n\n費用にも差が出ました。既定の設定では、1回目が0.039ドル、2回目と3回目が0.005ドルでした。同じ前置きがキャッシュに乗ると、約8分の1になります。つまり、前置きを小さくするだけでなく、毎回同じ前置きを送ることにも意味があります。\n\n## 切る前に知っておくこと\n\nツールを切ると、ファイルを読むことも書くこともできなくなります。記事を書かせる、文章を分類させる、といった、テキストを入れてテキストが返るだけの用途向けです。ファイルを触らせたい処理では、全部は切れません。\n\n測定には不安定な部分もありました。\n\n- `--tools \"\"` は3回中2回が2,184でしたが、1回だけ5,613になりました。理由は分かっていません。\n- `--disable-slash-commands` は18,786と20,479にばらつき、効果を言い切れません。\n- 筆者の環境はMCPやskillsが多いので、MCPや設定を切った効果は人によって違うはずです。\n\n1回の測定で判断せず、3回ほど測って同じ値に落ち着くかを見てください。まず既定の合計を測り、次に `--tools \"\"` だけを付けて比べてみてください。自分の環境でどこが重いかは、数字を見るのが早いです。"
    },
    {
      "condition": "6",
      "name": "自分のメモ",
      "run": 5,
      "cost_usd": 0.0325,
      "text": "# claude -p は「こんにちは」だけで約2万トークン使う。測って減らす\n\n`claude -p` に「こんにちは。1語で返事して」と投げただけで、入力トークンは20,404ありました。自分で書いたのは十数文字なので、残りは全部Claude Codeが付け足したものです。この記事では、その中身と測り方、減らし方を、私の手元の数字で書きます。\n\n測定は2026-10-08、Macで行いました。モデルは claude-sonnet-5-5、Claude Code は 2.1.291で、空のフォルダで実行し、設定ごとに3回ずつ走らせています。\n\n## 入力トークンの測り方\n\n`claude -p` は、あなたの一言の前に、ツールの定義、標準のシステムプロンプト、MCP、各種設定、skillsの情報などを付けて送ります。これらは目に見えないので、数字で確認するのが早いです。\n\n`--output-format json` を付けると、結果に `usage` が入ります。ここで落とし穴があります。`input_tokens` は2や3としか出ません。残りはキャッシュ側に入るからです。全体を見るには、次の3つを足します。\n\n- input_tokens\n- cache_creation_input_tokens\n- cache_read_input_tokens\n\njq があれば、1行で出せます。\n\n```bash\nclaude -p \"こんにちは。1語で返事して\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\n## 何を切ると、どれだけ減ったか\n\n同じ入力で、オプションだけ変えた結果です。数字は3つの合計です。\n\n| 設定 | 合計入力トークン |\n|---|---|\n| 何も付けない(既定) | 20,404 |\n| `--tools \"\"` | 2,184 |\n| `--strict-mcp-config` | 18,711 |\n| `--setting-sources \"\"` | 17,078 |\n| `--disable-slash-commands` | 18,786 / 20,479 |\n| 上の4つを全部付ける | 2,011 |\n| 全部付けて `--system-prompt \"You are a helpful assistant.\"` | 584 |\n\n一番効いたのは、ツールを切ることでした。MCPを読まなくしても約1,700、設定を読まなくしても約3,300しか減りません。ツールを切ると約18,000減るので、ツール定義だけでそれくらいの量があることになります。\n\n最後の584は、標準のシステムプロンプトを自分の一行に置き換えた結果です。2,011から584を引くと約1,400なので、標準のシステムプロンプトはそのくらいの量だったと読めます。\n\nばらつきも出ました。`--tools \"\"` は3回中2回が2,184でしたが、1回だけ5,613になりました。理由は分かっていません。`--disable-slash-commands` も18,786と20,479にばらつきました。1回測って決めず、数回測るほうが安全です。\n\n費用にも差が出ました。既定設定の1回目は0.039ドル、2回目と3回目は0.005ドルです。同じ前置きがキャッシュに乗ると、約8分の1になりました。同じ設定で繰り返し呼ぶスクリプトなら、前置きを小さくする効果に加えて、キャッシュの効果も受けられます。\n\n## 自分の環境で試す順番\n\n私の環境はMCPやskillsが多めなので、この数字がそのまま当てはまるとは限りません。次の順で試すと、自分の数字が分かります。\n\n1. 何も付けずに実行して、3つの合計を出す\n2. `--tools \"\"` だけを付けて、もう一度測る\n3. 差が大きければ、`--strict-mcp-config` や `--setting-sources \"\"` も足す\n4. 最後に `--system-prompt` で一行に置き換える\n\n全部を付けた形は次のとおりです。\n\n```bash\nclaude -p \"こんにちは。1語で返事して\" \\\n  --tools \"\" \\\n  --strict-mcp-config \\\n  --setting-sources \"\" \\\n  --disable-slash-commands \\\n  --system-prompt \"You are a helpful assistant.\" \\\n  --output-format json\n```\n\n注意点が1つあります。ツールを切ると、ファイルを読むことも書くこともできません。記事を書かせる、文章を分類させる、のようにテキストを入れて、テキストを返すだけの用途に向いています。ファイルを触らせたい処理では、ツールを残したうえで、MCPや設定の側から減らしてください。\n\nまずは何も付けない状態で1回測ってみてください。自分の環境の20,404にあたる数字が分かれば、どこを削るかが決められます。"
    },
    {
      "condition": "7",
      "name": "工程分け（構成→執筆→点検→書き直し）",
      "run": 1,
      "cost_usd": 0.167,
      "text": "# `claude -p \"hi\"` の入力トークンを測って減らす\n\n`claude -p \"hi\"` は数文字しか送っていませんが、入力トークンは数文字分では済みません。システムプロンプト、ツール定義、CLAUDE.md、MCPサーバーのツール定義も一緒に送られるからです。どれが重いかは環境で違うので、測って確かめます。\n\n## 各条件を2回ずつ測る\n\n条件を変えると先頭部分も変わるため、各条件の1回目はキャッシュ作成になります。そこで同じ条件を連続で2回実行し、2回目の値を使います。\n\n```bash\nclaude --version   # 結果と一緒に記録しておく\nmeasure() {\n  claude -p \"hi\" --output-format json \"$@\" >/dev/null\n  claude -p \"hi\" --output-format json \"$@\" | jq '{\n    input: (.usage.input_tokens // 0),\n    create: (.usage.cache_creation_input_tokens // 0),\n    read: (.usage.cache_read_input_tokens // 0),\n    total: ((.usage.input_tokens // 0) + (.usage.cache_creation_input_tokens // 0) + (.usage.cache_read_input_tokens // 0)),\n    cost: .total_cost_usd}'\n}\n```\n\n次の4行を実行して、total と cost を表に写します。\n\n```bash\nmeasure                                                            # そのまま\n(mkdir -p /tmp/empty && cd /tmp/empty && measure)                  # 空ディレクトリ\nmeasure --strict-mcp-config --mcp-config '{\"mcpServers\":{}}'      # MCPなし\nmeasure --tools \"Read,Grep\"                                        # ツール絞り\n```\n\nトークン数の増減は total で比べ、安くなったかどうかは cost で判断します。読み取りと作成は単価が違うため、total が減っても cost が同じように減るとは限りません。キー名やフラグが通らないときは、`jq` を外して出力全体を見るか、`claude --help` で `--tools` と `--mcp-config` の項目を確認してください。空ディレクトリでも `~/.claude/CLAUDE.md` のようなユーザー単位の設定は読み込まれます。\n\n「そのまま」との差分が、その要素の重さです。MCPサーバーを多く入れている環境なら、MCPなしの行で大きく減るはずです。\n\n## ログ要約ジョブで実際に削る\n\nジョブを「ログを要約する」に決めます。このジョブに必要なのは、読む力と探す力だけです。\n\n```bash\ncat app.log | claude -p \"エラーを重要度順に5行で要約して\" > before.txt\ncat app.log | claude -p \"エラーを重要度順に5行で要約して\" \\\n  --tools \"Read,Grep\" --strict-mcp-config --mcp-config '{\"mcpServers\":{}}' > after.txt\ndiff before.txt after.txt\n```\n\n残すのは Read と Grep で、外すのは編集系、実行系、MCPです。削減の前後で同じログを流し、`diff` で出力を見比べれば、要約の質が落ちていないか確認できます。文面は毎回揺れるので、差があるだけでは判断せず、拾うべきエラーが抜けていないかを見てください。\n\n`--system-prompt` で既定の指示を置き換えると、ツールの使い方まで変わることがあります。指示を足したいだけなら `--append-system-prompt` を使います。\n\n## 削らずに安くする\n\n外せないものは、キャッシュで安くします。固定の指示を先頭に置き、日時や実行IDのような可変部分は後ろに回します。先頭が変わると、そこから後ろは再利用されません。\n\nキャッシュの有効期間は、公式ドキュメントのプロンプトキャッシュの項で確認できます。自分の環境では、`measure` の1回目と2回目の間に `sleep` を挟み、間隔を変えて `create` と `read` がどう動くかを見れば分かります。\n\n## 採用する構成を決めて、毎回ログに残す\n\n先ほどの `after.txt` 側のコマンドが、最終形の候補です。スクリプトには、使用量を毎回残す処理も入れます。\n\n```bash\nout=$(claude -p \"$PROMPT\" --tools \"Read,Grep\" --strict-mcp-config --mcp-config '{\"mcpServers\":{}}' --output-format json)\necho \"$out\" | jq -c '{usage, cost: .total_cost_usd}' >> usage.log\necho \"$out\" | jq -r .result\n```\n\n`usage.log` の合計が急に増えたら、先頭の固定部分に可変情報が混ざっていないか、CLAUDE.md やMCP設定が増えていないかを確認します。"
    },
    {
      "condition": "7",
      "name": "工程分け（構成→執筆→点検→書き直し）",
      "run": 2,
      "cost_usd": 0.2043,
      "text": "# `claude -p \"hi\"` の入力トークンを測って減らす\n\nhi は2文字ですが、`claude -p` の usage に出る入力トークンは2文字分ではありません。この記事では、内訳を自分の環境で測り、削れるものを1つずつ外して差を見る手順を示します。私の環境の数字は載せません。MCP サーバーの数や CLAUDE.md の長さで値が大きく変わるので、比較の基準になるのは読者の手元の値だけだからです。\n\n## hi の前に付いてくるもの\n\n`claude -p` は、対話モードと同じ Claude Code のエージェントとして動きます。プロンプトの前に、次のものがリクエストへ入ります。\n\n- Claude Code 本体のシステムプロンプト\n- Bash、Read、Edit などの組み込みツールの定義\n- 接続している MCP サーバーのツール定義\n- CLAUDE.md などの指示ファイル（ユーザー単位とプロジェクト単位）\n- 作業ディレクトリや日付などの環境情報\n\nツールを1つも呼ばない hi でも、ツールの定義は毎回送られます。MCP サーバーを多く入れている人、CLAUDE.md が長い人は、土台が厚くなります。どの項目がどれだけ占めるかは、次の節で測ります。\n\n## 合計を出して測る\n\n`--output-format json` を付けると usage が取れます。見る項目は次の4つです。\n\n- `input_tokens`: キャッシュに載らなかった入力\n- `cache_creation_input_tokens`: 今回キャッシュに書き込んだ入力\n- `cache_read_input_tokens`: キャッシュから読み出した入力\n- `output_tokens`: 出力\n\n`input_tokens` だけを見ても入力の全体量は分かりません。入力の総量は、先頭3項目の合計です。\n\n```bash\nclaude -p \"hi\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\nこの合計は、キャッシュに当たったかどうかで内訳が変わっても、ほぼ同じ値になります。キャッシュが変えるのは合計ではなく、料金と速度に効く内訳のほうです。土台の大きさを比べるなら合計、課金への影響を見るなら `total_cost_usd` を見ます。\n\n## 変種を並べて差を見る\n\n土台の要素を1つずつ外し、そのたびに合計を出します。次のスクリプトは、同じディレクトリ、同じモデル、同じプロンプトで、変えるものを1回につき1つだけにしています。\n\n```bash\ntotal='.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\nt() { claude -p \"hi\" --output-format json \"$@\" | jq \"$total\"; }\n\necho \"base      $(t)\"\necho \"no-tools  $(t --tools \"\")\"\necho \"no-mcp    $(t --strict-mcp-config)\"\necho \"no-user   $(t --setting-sources project)\"\necho \"sys       $(t --system-prompt \"Answer briefly.\")\"\n```\n\n各行の意味は次のとおりです。\n\n- `--tools \"\"` は組み込みツールを無効にします。base との差が、ツール定義の大きさです。\n- `--strict-mcp-config` は、`--mcp-config` で指定したものだけを MCP として使います。指定しなければ MCP なしです。\n- `--setting-sources project` は、ユーザー設定とローカル設定を読まず、プロジェクト設定だけを読みます。CLAUDE.md の読み込みにも効くかどうかは、base との差で確認できます。\n- `--system-prompt` は、標準のシステムプロンプトを丸ごと置き換えます。base との差が、標準プロンプトの大きさの目安になります。\n\nこの最後の変種は、効果が大きい可能性があります。標準プロンプトという一番大きな固定部分を、自分の短い指示に入れ替えるからです。代わりに、ファイル編集やコマンド実行といった標準の振る舞いの指示も消えます。テキストの変換や分類のように、エージェントらしい動きが要らない用途で試してください。\n\nプロジェクトの CLAUDE.md の影響だけを見たいときは、空のディレクトリで同じスクリプトを回します。`mkdir /tmp/empty && cd /tmp/empty` で十分です。消えるのはそのプロジェクトの CLAUDE.md だけで、`~/.claude` 側のユーザー設定や、ユーザー単位の MCP 設定は残ります。それらを外すのが、上の `no-user` と `no-mcp` の役目です。\n\n指定したフラグが認識されないときは、お使いのバージョンにそのフラグがありません。`claude --help` で一覧を見て、近い名前のものに読み替えてください。\n\n## 減らせない分はキャッシュに任せる\n\nツールが必要で土台を削れないなら、キャッシュに当たりやすくします。プロンプトキャッシュは、リクエストの先頭から同じ内容が続く部分を再利用します。次の3点が効きます。\n\n- 同じディレクトリ、同じモデル、同じツール構成で続けて呼ぶ\n- 先頭に近い指示に日時やランダムな値を入れず、変わる部分は最後に置く\n- 呼び出しの間隔を空けすぎない。キャッシュには有効期間があり、切れると書き込みからやり直しになる\n\n確認は、上のスクリプトの `t` から jq の式を変えて、3項目を別々に出すだけです。バッチなら、1件目で `cache_creation`、2件目以降で `cache_read` が増えていれば当たっています。\n\n1件目から `cache_read` が大きく出ても、壊れてはいません。直前に同じ構成で実行していれば、そのキャッシュが残っているだけです。\n\n2件目以降に `cache_read` が増えないときは、次の順で疑います。\n\n1. 前回から時間が空いて、有効期間が切れていないか\n2. 並列で走らせていて、1件目の書き込みが済む前に次が始まっていないか\n3. フラグ、環境変数、作業ディレクトリ、モデルが呼び出しごとに変わっていないか\n4. 先頭に近い指示に、毎回変わる値が入っていないか\n\n上から順に、確認が簡単な原因です。\n\nまず、上のスクリプトを `measure.sh` として保存し、次のコマンドで実行してください。\n\n```bash\n{ date; ./measure.sh; } >> token-log.txt\n```\n\n次に、一番差が大きかった行の設定を自分のスクリプトへ入れ、もう一度実行します。結果が `token-log.txt` に日付つきで溜まるので、変更前後の差を後から見比べられます。"
    },
    {
      "condition": "7",
      "name": "工程分け（構成→執筆→点検→書き直し）",
      "run": 3,
      "cost_usd": 0.1849,
      "text": "## 同じ「hi」を、設定を変えて2回ずつ測る\n\n`claude -p \"hi\"` の入力トークンは、質問の長さでは決まりません。システムプロンプト、組み込みツールの定義、接続中の MCP サーバーのツール定義、CLAUDE.md、環境情報といった前提が毎回付くので、そちらが支配します。まず自分の環境で、その大きさを見てください。\n\n```bash\nclaude -p \"hi\" --output-format json > out.json\njq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens' out.json\njq '.total_cost_usd' out.json\n```\n\n`input_tokens` はキャッシュに乗らなかった分だけなので、実際の入力量は上の3欄の合計で見ます。フィールド名は `jq 'keys' out.json` で手元の出力と照らし合わせてください。\n\n次に、ツールと MCP を外して同じ測定をします。\n\n```bash\nclaude -p \"hi\" --tools \"\" --strict-mcp-config --output-format json > out2.json\n```\n\n記事を公開するときは、ここに自分の実測値を入れます。\n\n```\nclaude --version: 【記入】\n測定日: 【記入】\n通常:                        合計 【記入】 / total_cost_usd 【記入】\n--tools \"\" --strict-mcp-config: 合計 【記入】 / total_cost_usd 【記入】\n```\n\n## 変更後は2回走らせて、2回目の数字を採る\n\nフラグを変えると、リクエストの先頭部分が変わります。変更後の1回目は新しい内容をキャッシュに書き込むため、`cache_creation_input_tokens` が大きく出ます。この数字を前の基準と比べると、減ったはずの設定が増えたように見えます。\n\n変更するたびに同じコマンドを続けて2回実行し、2回目を記録してください。2回目で `cache_read_input_tokens` が増えていなければ、キャッシュが効いていません。その場合は、次の節の条件を疑います。\n\n合計はサイズの目安であって、費用ではありません。キャッシュから読んだ分は、書き込んだ分や通常の入力とは単価が違います。費用は `total_cost_usd` で比べてください。\n\n## 絞る順番と、それぞれの確認方法\n\n1つ変えては測り直します。フラグの綴りは、使う前に `claude --help` で確認してください。\n\n1. `--tools \"Read\"` のように、使うツールだけを渡します。整形のようにツールが要らない処理は `--tools \"\"` で外します。\n2. `--strict-mcp-config` を付けると、`--mcp-config` で渡した MCP だけが読まれます。付けても合計が変わらなければ、その環境には元から MCP が入っていません。\n3. 空のディレクトリで同じコマンドを実行します。数字が下がれば、プロジェクトや home の CLAUDE.md と設定が効いています。読み込み元は `--setting-sources` で絞れます。\n4. `--system-prompt` で既定のシステムプロンプトを置き換えます。\n\n4番は、数字が下がっても採用を急がないでください。既定のプロンプトにはコーディング作業向けの指示が入っているので、置き換えるとツールの使い方や出力の癖が変わります。トークンを測ったあとに、出力の中身も読んで確かめます。変換や分類のような単純な用途に限って使うのが安全です。\n\n## 残る分はキャッシュに乗せ続ける\n\n絞っても固定部分は残ります。ここは減らすのをやめて、キャッシュが外れない呼び方に寄せます。キャッシュはリクエストの先頭から同じ内容が続く範囲で効き、既定の保持時間は5分です。数字は Anthropic 公式ドキュメントのプロンプトキャッシュの項に書かれているので、公開前に最新の値を確認してください。\n\n- 実行のたびにフラグを変えない。ツールやシステムプロンプトが変わると、先頭から別物になります。\n- 日時やファイル名のように毎回変わる情報は、プロンプトの後ろに置く。\n- 連続して呼ぶ間隔は5分以内にする。\n- 並列で起動する前に、1回だけ先に走らせる。\n\n並列の件は、自分で確かめられます。同じコマンドを `&` で3つ同時に起動した場合と、1回走らせてから3つ流した場合で、それぞれ `usage` を比べてください。前者で3つとも `cache_creation_input_tokens` が大きければ、同時起動では書き込みが重複しています。\n\n## 最後にやること\n\n自分のスクリプトが実際に使っているフラグで基準値を測り、変更前後を3行の表にします。\n\n| 設定 | 合計トークン(2回目) | total_cost_usd(2回目) |\n|---|---|---|\n| 現在のフラグ | | |\n| ツールと MCP を絞る | | |\n| さらに空ディレクトリで実行 | | |\n\n差が小さかった変更は戻します。残った設定を、スクリプトのフラグに固定してください。"
    },
    {
      "condition": "7",
      "name": "工程分け（構成→執筆→点検→書き直し）",
      "run": 4,
      "cost_usd": 0.1586,
      "text": "# `claude -p \"hi\"` の入力トークンを測って、内訳を分けて、削る\n\n`claude -p \"hi\"` は一言を送るだけのコマンドですが、入力トークンはその一言よりずっと大きくなります。まず自分の環境の数字を出します。\n\n私の環境(Claude Code【バージョン】、macOS、【実行ディレクトリ】)の結果は次のとおりでした。\n\n```\n【ここに下のjqコマンドの出力を貼る】\n```\n\n## 3つの数字を取り出す\n\n出力JSONは長いので、`jq` で必要な項目だけ抜きます。\n\n```\nclaude -p \"hi\" --output-format json | jq '{input: .usage.input_tokens, create: .usage.cache_creation_input_tokens, read: .usage.cache_read_input_tokens, cost: .total_cost_usd}'\n```\n\n「入力が大きい」とは、`input_tokens`、`cache_creation_input_tokens`、`cache_read_input_tokens` の合計です。`input_tokens` だけを見ると小さく見えます。同じコマンドをもう一度実行して、`create` と `read` の値がどう動いたかも記録してください。私の2回の結果は【1回目: create=__ read=__ / 2回目: create=__ read=__】でした。\n\n## 空のディレクトリで内訳を切り分ける\n\nプロンプト以外に、システムプロンプト、組み込みツールの定義、CLAUDE.md、MCPサーバーのツール定義などが送られます。何がどれだけかは、環境を削って差を見るのが確実です。\n\n```\nmkdir -p /tmp/empty && cd /tmp/empty\nclaude -p \"hi\" --output-format json | jq '.usage'\n```\n\n空のディレクトリで残る分は、本体の固定部分とは限りません。`~/.claude` のCLAUDE.mdや設定、ユーザースコープのMCPが読み込まれている可能性があります。ユーザー設定を外すには `--setting-sources project` を足します。MCPを外すには、`--mcp-config` を渡さずに `--strict-mcp-config` を付けます。\n\n```\nclaude -p \"hi\" --output-format json --setting-sources project --strict-mcp-config | jq '.usage'\n```\n\n手元の結果では、通常のプロジェクトが【合計__】、空のディレクトリが【合計__】、ユーザー設定とMCPも外した状態が【合計__】でした。この差が、プロジェクト、ユーザー設定、MCPそれぞれの寄与です。\n\n## 1つずつ外して再計測する\n\n変えるのは1回に1つだけです。複数を同時に変えると、どれが効いたのか分からなくなります。\n\n```\nclaude -p \"hi\" --output-format json --tools \"\"\nclaude -p \"hi\" --output-format json --disable-slash-commands\nclaude -p \"hi\" --output-format json --system-prompt \"Answer briefly.\"\n```\n\n`--tools \"\"` は組み込みツールをすべて無効にします。使うのは要約や分類のようにツールが要らない処理だけにしてください。ファイル編集やコマンド実行を任せる処理では、必要なツールを残します。`--system-prompt` は既定のシステムプロンプトを置き換えるので、挙動も変わります。トークンだけでなく出力の品質も確認してください。\n\n結果は表に残します。効果がなかった変更も書いてください。\n\n| 条件 | input | create | read | cost |\n|---|---|---|---|---|\n| 既定 | 【測定値】 | 【測定値】 | 【測定値】 | 【測定値】 |\n| `--tools \"\"` | 【測定値】 | 【測定値】 | 【測定値】 | 【測定値】 |\n| `--strict-mcp-config` | 【測定値】 | 【測定値】 | 【測定値】 | 【測定値】 |\n| `--disable-slash-commands` | 【測定値】 | 【測定値】 | 【測定値】 | 【測定値】 |\n\nこれらのフラグはバージョンによって名前や挙動が変わりえます。私は【バージョン】で確認しました。手元では `claude --help` で確認してから使ってください。\n\n## 削るか、キャッシュに任せるか\n\nプロンプトキャッシュは、毎回同じ前半部分を保存して再利用する仕組みです。保存の有効期間は公式ドキュメント(Prompt caching のページ)に書かれています。読み取りと書き込みの単価も、公式の料金ページで確認できます。ここでは数字を引かず、自分の環境で実験します。\n\n1. 同じコマンドを続けて2回実行し、`create` と `read` を記録する\n2. 公式ドキュメントの有効期間より長く待ってから、もう1回実行して記録する\n\n2回目で `read` が大きくなり、待ったあとの実行で `create` に戻るなら、あなたの環境ではキャッシュが期待どおり動いています。短い間隔で繰り返し呼ぶスクリプトなら、固定部分は読み取りに回るので、削る効果は小さくなります。呼び出しの間隔が長いバッチなら、毎回作成になるので、削った分がそのまま効きます。\n\n次の一歩として、自分のスクリプトの `claude -p` の直後に、先ほどの `jq` の1行を足してください。実行のたびに3つの数字とcostが残るので、どの変更が効いたのかを後から確かめられます。\n\n---\n注: 【】の部分は、私が実際にコマンドを実行できる環境になかったため空けています。ご自身の実測値とバージョンを入れてから公開してください。"
    },
    {
      "condition": "7",
      "name": "工程分け（構成→執筆→点検→書き直し）",
      "run": 5,
      "cost_usd": 0.1512,
      "text": "# `claude -p \"hi\"` の入力トークンを測って、減らす\n\n`claude -p \"hi\"` を実行して使用量を見ると、送ったのは二文字なのに、入力トークンが予想より大きいことがあります。この記事では、手元で測り、内訳を推測し、条件を1つずつ変えて差を見ます。数字はあなたの環境で出したものだけを使うので、ここには載せません。\n\n## まず「hi」で測る\n\n最初にバージョンを控え、`usage` を出します。`jq` が必要です。\n\n```bash\nclaude --version\nclaude -p \"hi\" --output-format json | jq '.usage'\n```\n\n見るのは `input_tokens`、`cache_creation_input_tokens`、`cache_read_input_tokens` の3つです。キャッシュに書き込まれた分、キャッシュから読まれた分、どちらでもない分に分かれて数えられるので、入力全体の大きさは合計で見ます。\n\n```bash\nclaude -p \"hi\" --output-format json | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\nこれを間を空けずに2回実行してください。期待する変化は、1回目は `cache_creation_input_tokens` が大きく、2回目はその分が `cache_read_input_tokens` に移ることです。合計はほぼ同じで、中身の配分だけが動きます。この形になれば、キャッシュが働いています。\n\n## 内訳を推測する\n\n合計が大きいなら、「hi」以外の何かが毎回付いているはずです。候補は次の4つです。\n\n- システムプロンプト。差し替えて変化を見ます。\n- 組み込みツールの定義。ツールを空にして変化を見ます。\n- MCPサーバーのツール定義。MCPを外して変化を見ます。\n- CLAUDE.md。置かれていないディレクトリで実行して変化を見ます。\n\nこれは推測です。たとえばMCPを1つも入れていない人は、MCPを外しても合計が動かず、その層は元々ゼロだったと分かります。推測が外れること自体が、測定の成果です。\n\n## 1つずつ外して比べる\n\n一度に複数を変えると、どれが効いたのか分からなくなります。変えるのは1回に1つです。次のフラグは `claude --help | grep -e \"--tools\"` のように、自分の版にあるか先に確認してください。なければその行は飛ばします。\n\n```bash\n# 組み込みツールを空にする\nclaude -p \"hi\" --tools \"\" --output-format json | jq '.usage'\n\n# 設定済みのMCPを読み込まない（--mcp-config を渡さなければMCPなし）\nclaude -p \"hi\" --strict-mcp-config --output-format json | jq '.usage'\n\n# システムプロンプトを短いものに置き換える\nclaude -p \"hi\" --system-prompt \"Reply briefly.\" --output-format json | jq '.usage'\n\n# CLAUDE.md のないディレクトリで実行する\n(cd \"$(mktemp -d)\" && claude -p \"hi\" --output-format json | jq '.usage')\n```\n\n最後の例では、`~/.claude/CLAUDE.md` のようなユーザー単位のファイルは読まれる可能性があります。差が出なければ、そこも疑ってください。結果は次の表に書き込みます。バージョンの欄も忘れずに。\n\n| 条件 | input | creation | read | 合計 |\n|---|---|---|---|---|\n| 普段の設定(hi) | | | | |\n| ツールを空に | | | | |\n| MCPなし | | | | |\n| システムプロンプト置換 | | | | |\n| CLAUDE.mdなし | | | | |\n\n読み方は単純です。普段の行との合計の差が大きい行ほど、その層が重いということです。削る候補は、差が大きい行から順に検討します。\n\nただし、削ると失うものがあります。ツールを空にすれば、ファイル操作などはできません。CLAUDE.mdを外せば、プロジェクトの規約が反映されません。スクリプトがそれを必要としないと確認できたものだけを外してください。\n\n## 削らずに安くする: キャッシュの間隔を測る\n\n外せない層は、キャッシュに任せます。気になるのは、呼び出しの間隔をどこまで空けても `cache_read_input_tokens` が出るか、です。これは文章で答えを書くより、測ったほうが確実です。\n\n```bash\nclaude -p \"hi\" --output-format json > /dev/null\nfor s in 5 60 600; do\n  sleep \"$s\"\n  claude -p \"hi\" --output-format json | jq -c --arg s \"$s\" '{wait: $s, read: .usage.cache_read_input_tokens}'\ndone\n```\n\n待ち時間を伸ばして `read` が0に戻る境目が、あなたの環境での目安になります。もう1つ確認したいのは、プロンプトの先頭に日時のような毎回変わる文字列を入れていないかです。先頭が変わると、キャッシュが効きにくくなることがあります。入れているスクリプトは、固定部分を先頭、変わる部分を末尾に並べ替えて、同じ測定をやり直してください。\n\n最後に、今日やることを1つ決めます。表の1行目を、あなたの環境の「hi」で埋めてください。埋まったら、次に外す項目を1つだけ選びます。実際のプロンプトでの測定は、その後です。"
    },
    {
      "condition": "8",
      "name": "短いメモ（3行）",
      "run": 1,
      "cost_usd": 0.0269,
      "text": "`claude -p` に「こんにちは。1語で返事して」と送るだけで、入力トークンは2万を超えます。自分のMacで測ったところ、合計は20,404でした。スクリプトに組み込んで何度も呼ぶ用途では、この下地の大きさがそのまま効いてきます。この記事では、測り方と、何が効いて減ったかを書きます。\n\n## 一言なのに2万トークンになる\n\n測った条件は次のとおりです。\n\n- 日付: 2026-10-08\n- モデル: claude-sonnet-5-5\n- Claude Code: 2.1.291\n- 場所: 空のフォルダ\n- 送った文: 「こんにちは。1語で返事して」\n\n自分が打った文字数は十数文字です。それでも20,404トークンになるのは、`claude -p` が毎回、ユーザーの文章の前にClaude Code側の指示や道具の定義を付けて送るからです。\n\n数え方も決めておきます。入力トークンは3つの数字に分かれて返ってきます。`input_tokens`、`cache_creation_input_tokens`、`cache_read_input_tokens` で、この記事ではその合計を「入力トークン」と呼びます。キャッシュに書き込んだ分も、キャッシュから読んだ分も、モデルに渡った量としては同じだからです。課金上の扱いはキャッシュの状態で変わりますが、まず「何が渡っているか」を見るために、合計で比べます。\n\n## 自分の環境で測る\n\nJSON形式で出力させて、usageの欄を足します。\n\n```bash\nclaude -p \"こんにちは。1語で返事して\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\nusageの欄の構造はバージョンで変わる可能性があります。数字が出なければ、`jq` を外して生のJSONを眺め、3つのフィールドの場所を確かめてください。\n\n測るときは、次の3点を揃えます。\n\n1. 毎回同じフォルダで実行する。フォルダ内の設定ファイルが入力に混ざるのを避けるため、最初は空のフォルダが向いています。\n2. 同じ文を送る。\n3. 一度に変えるオプションは1つだけにする。\n\n3つ目が大事です。複数を同時に変えると、どれが効いたのか分からなくなります。\n\n## 減ったのはツールだった\n\n何も付けずに測ると20,404でした。ここに `--tools \"\"` を付けると2,184になります。差し引き18,220トークンで、ツールの定義だけで入力の9割近くを占めていたことになります。\n\n意外だったのはMCPとの比較です。MCPサーバーを外しても減ったのは約1,700でした。「外部の道具をつなぐと重くなる」というイメージがあったので、MCPが主因だと思っていました。実際には、最初から入っている標準のツール群の定義が、ずっと大きな割合を占めていました。\n\nなお、残った2,184に何が入っているかは、今回は分解していません。ツール以外の指示文などだろうと推測はできますが、測っていないので断定はしません。\n\n## 使うときの注意\n\n`--tools \"\"` は、ツールを1つも使わせない指定です。ファイルを読む、コマンドを実行するといった動作はできなくなります。向いているのは、次のような「文章を渡して文章を返してもらう」だけの処理です。\n\n- 文章の要約\n- 分類\n- 整形\n- 翻訳\n\nファイル操作が必要な処理では、全部を切るのではなく、必要なツールだけに絞る方向を試すことになります。その場合の削減量は今回測っていないので、自分の環境で同じ手順で確かめてください。\n\n試す順番は次のとおりです。\n\n1. 上のコマンドで、何も付けない状態の合計を記録する。\n2. `--tools \"\"` を付けて、もう一度測る。\n3. 自分のスクリプトで本当に使うツールだけを残し、同じ文でもう一度測る。\n4. MCPサーバーを使っているなら、外した場合も測り、差が自分の環境でどのくらいあるかを見る。\n\n私の環境ではツールが最大の要因でしたが、MCPサーバーを多く入れている環境では割合が違うかもしれません。数字は環境ごとに違うので、まず自分の `claude -p` の下地を測るところから始めるのが確実です。"
    },
    {
      "condition": "8",
      "name": "短いメモ（3行）",
      "run": 2,
      "cost_usd": 0.0391,
      "text": "# claude -p は一言送るだけで2万トークンを使う。測って減らす\n\n## 一言でも入力が2万トークンを超える\n\n2026-10-08に、自分のMacで `claude -p` の入力トークンを測りました。モデルは claude-sonnet-5-5、Claude Code は 2.1.291、場所は空のフォルダです。送ったのは次の一文だけです。\n\n```\nclaude -p \"こんにちは。1語で返事して\"\n```\n\n入力トークンの合計は 20,404 でした。ここでの合計は、`input_tokens`、`cache_creation_input_tokens`、`cache_read_input_tokens` の3つを足したものです。\n\n私が打った文字は十数文字なので、残りは Claude Code が自分で付け足していることになります。Claude Code は単なるチャットではなく、ファイルを読んだりコマンドを実行したりするエージェントです。そのため、使えるツールの定義(名前、説明、引数の形)をリクエストのたびにモデルへ渡します。これらも入力トークンとして数えられます。\n\n## 自分の環境で測る\n\n測るには、JSON形式で出力させて `usage` を読みます。ここでは `jq` を使います。\n\n```\nclaude -p \"こんにちは。1語で返事して\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\n3つを足す理由は、キャッシュの状態で内訳が変わるからです。`input_tokens` はキャッシュされなかった分、`cache_creation_input_tokens` はキャッシュに書き込んだ分、`cache_read_input_tokens` はキャッシュから読んだ分です。同じ内容を送っていても、1回目と2回目で内訳は入れ替わります。合計で見れば、モデルに渡った量を比べられます。\n\n測る場所は空のフォルダにしてください。フォルダにプロジェクト用の設定ファイルなどがあると、その分が入力に加わることがあります。まず何も付けずに測り、これを基準値にします。\n\n## ツールを切ると約1万8千トークン減った\n\n基準値 20,404 に対して、`--tools \"\"` を付けると 2,184 になりました。\n\n```\nclaude -p \"こんにちは。1語で返事して\" --tools \"\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\n差し引きすると約1万8千トークンです。入力の大半がツールの定義だったことになります。\n\n意外だったのはMCPとの比較です。入力が大きいのは外部のMCPサーバーを繋いでいるせいだと考えて、先にMCPを切ってみました。しかし減ったのは約1,700トークンで、ツール全体を切ったときの10分の1に届きません。重いのはMCPではなく、Claude Code に最初から入っているツール群のほうでした。\n\n`--tools \"\"` で残った 2,184 トークンは、ツール以外の部分です。この数字は、今回の条件でこれ以上は削れない目安として使えます。\n\nただし、ツールを切るとファイルを読むことも、コマンドを実行することもできなくなります。文章を渡して文章を返してもらう用途、たとえば要約、分類、文面の整形などに向いています。ファイル操作が必要なスクリプトでは使えません。\n\n## 数字を自分の環境に当てはめる\n\nここまでの数字は、私の環境での1回の測定です。バージョンやモデルが変われば値も変わるはずなので、そのまま信じず、自分の環境で測ってください。手順は3つです。\n\n1. 空のフォルダで、何も付けずに合計を測る\n2. オプションを1つだけ付けて、もう一度測る\n3. 基準値との差を見て、効いたものだけを残す\n\nオプションを一度に複数付けると、どれが効いたのか分からなくなります。1つずつ試すのが確実です。\n\nもう1つ、トークン数と料金は同じものではありません。キャッシュから読まれた分は、通常の入力とは別の扱いで課金されます。合計が大きいことと、その全部が通常料金で請求されることは別の話です。実際の費用は、自分が使っているプランや料金表で確認してください。\n\nトークンを減らす目的が速度なのか、費用なのか、上限に当たらないようにするためなのかでも、見るべき数字は変わります。まず基準値を測っておけば、どの目的でも変化を比べられます。"
    },
    {
      "condition": "8",
      "name": "短いメモ（3行）",
      "run": 3,
      "cost_usd": 0.0292,
      "text": "## 一言送るだけで2万トークン\n\n`claude -p` に「こんにちは。1語で返事して」と送るだけで、入力トークンの合計は20,404でした。2026年10月8日に自分のMac（モデルは claude-sonnet-5-5、Claude Code 2.1.291、空のフォルダ）で測った値です。入力トークンは `input_tokens`、`cache_creation_input_tokens`、`cache_read_input_tokens` の3つを足したものです。\n\n私が書いたのは十数文字なので、残りはClaude Codeが自動で付け足しています。ツールの定義などが毎回リクエストに含まれるためです。ここで言うツールとは、ファイルの読み書きやコマンド実行のように、Claudeが呼び出せる機能のことです。モデルがツールを使うには、名前、説明、引数の形をあらかじめ渡しておく必要があります。\n\n## 自分の環境で測る\n\nまず JSON 形式で出力させ、使用量を見ます。\n\n```\nclaude -p \"こんにちは。1語で返事して\" --output-format json\n```\n\n出力の `usage` に、先ほどの3つの数字が入っています。`jq` が入っていれば、次のように絞れます。\n\n```\nclaude -p \"こんにちは。1語で返事して\" --output-format json | jq '.usage'\n```\n\n3つを足した値を、比較用の基準にしてください。内訳が毎回変わるのは、プロンプトキャッシュの状態によります。同じ内容を続けて送ると、2回目以降は `cache_creation_input_tokens` が減り、`cache_read_input_tokens` に回ることがあります。キャッシュから読まれた分は通常の入力より安く扱われますが、トークン数としては入力に数えられます。そのため、減らす工夫の効果を見るには3つの合計で比べるのが分かりやすいです。\n\n## ツールを切ると約1万8千トークン減った\n\n次に、ツールを無効にして同じ質問を送りました。\n\n```\nclaude -p \"こんにちは。1語で返事して\" --tools \"\" --output-format json\n```\n\n合計は2,184でした。20,404から約1万8千トークン減ったことになります。\n\n意外だったのは、MCPを切っても減ったのは約1,700だったことです。入力が重いのはMCPサーバーのせいだろうと予想していましたが、空のフォルダでは大半が組み込みのツール定義でした。MCPを何も設定していない環境なら、そもそもこの部分は効きません。\n\nツール以外の約2,200トークンの内訳までは、今回は調べていません。ただ、ここまで下がれば、一言の質問でも入力は桁がひとつ小さくなります。\n\n## 切ってよいかの判断\n\n`--tools \"\"` は、Claudeがファイルを読むことも、コマンドを実行することもできなくなる設定です。向いているのは、文章を渡して文章を返してもらう処理です。たとえば次のような用途です。\n\n- 渡したテキストの要約や分類\n- コミットメッセージ案の生成\n- ログの一部を貼って意味を尋ねる\n\n逆に、リポジトリのコードを読ませたり、修正させたりする処理では、ツールを切ると仕事になりません。その場合は全部を切らずに、必要なものだけ残す方向で考えます。使えるツールの指定方法は `claude --help` で確認できます。\n\n注意点が2つあります。ひとつは、私の数字が空のフォルダで1回測った結果だということです。作業フォルダに設定ファイルなどがあれば、入力はさらに増えるはずなので、自分のスクリプトを動かすフォルダで測り直してください。もうひとつは、バージョンやモデルが変わると数字も変わりうることです。\n\n試す順番は次のとおりです。\n\n1. 何も付けずに `--output-format json` で測る\n2. `--tools \"\"` を付けて測る\n3. 差が大きければ、その処理にツールが本当に要るかを考える\n\n自動化で何十回、何百回と呼び出す処理なら、1回あたりの差がそのまま積み上がります。まずは1回ずつ測って、自分の環境の数字を手に入れるところから始めてください。"
    },
    {
      "condition": "8",
      "name": "短いメモ（3行）",
      "run": 4,
      "cost_usd": 0.0287,
      "text": "# claude -p は「こんにちは」だけで2万トークン使う\n\n`claude -p` に「こんにちは。1語で返事して」と送るだけで、入力トークンは約2万になります。私の環境で測ったら20,404でした。質問は十数文字なのに、です。この記事では、測り方と、減らし方を順に書きます。\n\n## 何を足して2万トークンなのか\n\n数字は2026年10月8日に自分のMacで測ったものです。モデルはclaude-sonnet-5-5、Claude Codeは2.1.291、実行場所は空のフォルダでした。入力トークンは `input_tokens`、`cache_creation_input_tokens`、`cache_read_input_tokens` の3つの合計で見ています。\n\n`claude -p` は、あなたの一言だけをモデルに送っているわけではありません。毎回、Claude Codeが用意した指示文と、使えるツールの定義が一緒に送られます。ツールの定義とは、「ファイルを読む」「コマンドを実行する」といった機能の名前、説明、引数の形を書いた文章です。モデルはこれを読んで初めて、使えるツールを知ります。\n\nこの定義が大きいのです。次の節で数字を見ます。\n\n## 自分の環境で測る\n\n`--output-format json` を付けると、結果に使用量(`usage`)が含まれます。jq が入っていれば、合計は次のように出せます。\n\n```bash\nclaude -p \"こんにちは。1語で返事して\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\n3つを足すのは、プロンプトキャッシュの影響で内訳が実行ごとに動くからです。キャッシュとは、前に送った部分を使い回す仕組みです。初回は `cache_creation_input_tokens` に入り、2回目以降は `cache_read_input_tokens` に移ることがあります。合計なら、キャッシュの状態に左右されず、送った入力の大きさを比べられます。\n\nなお、キャッシュから読んだ分は、通常の入力より安く扱われます。ただ、合計が大きいことと請求額の大きさは同じではありません。ここで見ているのは、毎回モデルに渡している量です。\n\n私の環境では、何も付けずに実行すると20,404でした。まずは自分の環境で同じコマンドを打ち、基準の数字を控えてください。プロジェクトのフォルダで実行すれば、CLAUDE.md などが加わって、私の数字より大きくなることもあるでしょう。\n\n## ツールを切ると約1万8千減る\n\n減らす方法として、まずMCPを切ってみました。MCPは外部のサービスをつなぐ仕組みで、サーバーを入れるとツールが増えます。切ると減りましたが、減少は約1,700トークンでした。\n\n次に、組み込みのツールそのものを切りました。\n\n```bash\nclaude -p \"こんにちは。1語で返事して\" --tools \"\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\n`--tools \"\"` を付けた結果は2,184でした。20,404から約1万8千トークンの減少です。意外だったのは、MCPよりも、最初から入っている組み込みツールの定義のほうがずっと大きかったことです。MCPを疑う前に、ツール全体を疑うほうが近道かもしれません。\n\n残った2,184は、ツール以外の部分です。中身までは分けて測っていないので、ここでは「ツール以外の固定の部分」とだけ言っておきます。\n\n## 切ってよいかは、仕事の中身で決める\n\n`--tools \"\"` を付けると、Claudeはファイルを読むことも、コマンドを実行することもできなくなります。使える場面は限られます。\n\n- 渡した文章の要約、分類、翻訳、書き直し\n- 標準入力で渡したログやdiffの説明\n- 一言で答えられる質問\n\nこうした「入力を渡して、テキストを返してもらう」だけの仕事なら、ツールは要りません。反対に、リポジトリを読んで調べる仕事や、ファイルを書き換える仕事には、ツールが必要です。\n\nその中間もあります。`--tools` は、使うツールの名前を並べて指定できます。読むだけの仕事なら、必要な数個に絞ってから測ってみてください。どのツールがどれだけ重いかは、私のメモにはありません。1つずつ足しながら合計を測れば、自分の環境の答えが出ます。\n\n手順をまとめます。\n\n1. 同じ短い質問で、何も付けずに合計を測る\n2. `--tools \"\"` を付けて測る\n3. 仕事に必要なツールだけを `--tools` で指定して測る\n4. MCPを使っているなら、切る前と後を比べる\n\nスクリプトに組み込む前に、この4回を実行するだけで、毎回送っている量が見えるようになります。数字は環境やバージョンで変わるので、私の20,404と2,184は目安にして、自分の数字を基準にしてください。"
    },
    {
      "condition": "8",
      "name": "短いメモ（3行）",
      "run": 5,
      "cost_usd": 0.0344,
      "text": "# `claude -p` の入力トークンはなぜ大きいのか、どう減らすか\n\n`claude -p` をスクリプトに組み込むと、一言返すだけの呼び出しでも入力トークンが思ったより大きいことに気づきます。私のMacで実際に測ったところ、「こんにちは。1語で返事して」と送るだけで2万トークンを超えました。この記事では、その内訳の考え方と、自分の環境で測って減らす手順を書きます。\n\n## 一言で2万トークン\n\n測定の条件は次のとおりです。\n\n- 日付: 2026-10-08\n- モデル: claude-sonnet-5-5\n- Claude Code: 2.1.291\n- 場所: 空のフォルダ\n- 送った文: 「こんにちは。1語で返事して」\n\n入力トークンの合計(`input_tokens` + `cache_creation_input_tokens` + `cache_read_input_tokens`)は、何も付けないと20,404でした。`--tools \"\"` を付けると2,184になりました。差は18,220、約1万8千トークンです。\n\nもう一つ、意外な結果がありました。MCPを切っても減ったのは約1,700だけで、ツールを切ったときの減り方に比べるとずっと小さかったのです。重いのはMCPだろうと思い込んでいたので、これは予想と違いました。\n\nなぜツールで大きく変わるのか。モデルは、使えるツールの名前、説明、引数の仕様を読んで初めて「このツールを使える」と判断します。そのため、ツールの定義は毎回のリクエストに入力として含まれます。こんにちはと返すだけの場面でも、使うかもしれないツールの説明書が全部付いてくるわけです。残りの2,184の内訳までは測っていません。\n\n## 自分の環境で測る\n\n測るときは JSON 形式で出力させ、`usage` を見ます。\n\n```bash\nclaude -p \"こんにちは。1語で返事して\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\n3つを足しているのには理由があります。プロンプトキャッシュは、前回と同じ先頭部分を使い回す仕組みです。キャッシュが効くと、使い回された分は `input_tokens` ではなく `cache_read_input_tokens` に入ります。最初に書き込まれた分は `cache_creation_input_tokens` です。`input_tokens` だけを見ると、実際にモデルへ渡った量よりずっと小さく見えてしまいます。\n\n`jq` でエラーが出るときは、`--output-format json` の出力をそのまま眺めて `usage` の場所を確かめてください。\n\n## ツールを切って減らす\n\nツールを全部切るには `--tools \"\"` を付けます。\n\n```bash\nclaude -p \"こんにちは。1語で返事して\" --tools \"\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\n私の環境では、これで20,404が2,184になりました。\n\nただし、ツールなしではファイルを読むことも、コマンドを実行することもできません。文章の要約、分類、書き換えのように、渡したテキストだけで済む処理なら問題ありません。ファイルを読ませたいなら、必要なものだけ名前で指定する方法もあります。\n\n```bash\nclaude -p \"...\" --tools \"Read,Grep\"\n```\n\nこちらは私の測定には入っていないので、減る量は自分で確かめてください。\n\n## 比べて決める\n\n最後に、手順をまとめます。\n\n1. 普段使う呼び出しを、何も付けずに実行して合計を記録する。\n2. 同じ呼び出しに `--tools \"\"` を付けて、もう一度測る。\n3. 必要なツールだけを `--tools` で指定して、さらに測る。\n4. MCPサーバーを使っているなら、切った場合も測る。\n\n私の数字は空のフォルダでの結果です。普段の作業フォルダやMCPの設定が違えば、数字も変わります。そのため、手順1から4は自分のスクリプトを動かすフォルダで実行してください。\n\n測るときは、同じ呼び出しを2回続けて実行するのも勧めます。1回目は `cache_creation_input_tokens` に、2回目は `cache_read_input_tokens` に数字が移る様子が見えるはずで、プロンプトキャッシュの動きを自分の目で確認できます。合計は変わらなくても、内訳が動くところを見ておくと、あとで数字を読むときに迷いません。\n\n私の測定では、減らす効果が大きかったのはMCPよりもツールの定義でした。自分の環境でも同じとは限らないので、まず1回測ってみてください。"
    },
    {
      "condition": "9",
      "name": "メモ＋工程分け",
      "run": 1,
      "cost_usd": 0.2101,
      "text": "# 「こんにちは」に2万トークン。`claude -p` の入力を測って減らす\n\n`claude -p` に「こんにちは。1語で返事して」と渡すと、返事は1語なのに入力は20,404トークンありました。削れるだけ削った構成では584です。この差を自分の環境で確かめる手順を、私の測定値と一緒に書きます。\n\n## 測り方は3つの数字を足す\n\n測定は2026年10月8日、自分のMacで、Claude Code 2.1.291、モデルは claude-sonnet-5-5 です。実行は空のフォルダで行いました。普段のプロジェクトで測ると、そこにある設定などが加わって数字が変わるはずなので、私の表とそのまま比べないでください。\n\n```\nclaude -p \"こんにちは。1語で返事して\" --output-format json > out.json\njq '[.usage.input_tokens, .usage.cache_creation_input_tokens, .usage.cache_read_input_tokens] | add' out.json\njq '.total_cost_usd' out.json\n```\n\nJSONの usage にある input_tokens は、2か3しか出ません。残りはキャッシュ側に入るので、cache_creation_input_tokens と cache_read_input_tokens を足して初めて全体になります。null が出たら `jq . out.json` で項目の位置を確かめてください。\n\n何も付けない既定は、3回とも20,404でした。\n\n## 切って測る\n\nまず、オプションを単独で足した結果です。数字は3項目の合計で、各3回ずつ測りました。\n\n| 設定 | 合計入力トークン |\n|---|---|\n| 何も付けない | 20,404 |\n| `--tools \"\"` | 2,184 |\n| `--strict-mcp-config` | 18,711 |\n| `--setting-sources \"\"` | 17,078 |\n| `--disable-slash-commands` | 18,786と20,479 |\n\nツールを切ると2,184まで落ちました。ただし3回中2回で、1回だけ5,613になりました。理由は分かりません。スラッシュコマンドを切った設定も値が割れたので、1回の測定で結論を出さないほうがいいと分かりました。\n\nMCPを切って減ったのは約1,700、設定を切って約3,300です。ツールを切ったときの約1万8千という減り方は、それらと桁が違います。大半がツール定義だと考えられますが、内訳までは確かめていません。\n\n次に、組み合わせた結果です。\n\n```\nclaude -p \"こんにちは。1語で返事して\" --output-format json \\\n  --tools \"\" --strict-mcp-config --setting-sources \"\" --disable-slash-commands\n```\n\nこれで2,011になり、3回とも同じ値でした。ここへ `--system-prompt \"You are a helpful assistant.\"` を足すと584で、これも3回同じです。差の約1,400は、標準のシステムプロンプトを自分の一行に置き換えた分と読めます。\n\n## 切ると失うものと、費用\n\n`--tools \"\"` にすると、ファイルを読むことも書くこともできません。記事を書かせるだけ、分類させるだけ、という用途向けです。ファイルを触らせる処理には使えません。また、私の環境はMCPやskillsが多いので、減り幅は人によって違うはずです。\n\n費用も見ておきます。既定の設定では、1回目が0.039ドル、2回目と3回目が0.005ドルで、約8分の1でした。同じ前置きがキャッシュに乗った結果だと考えていますが、実行の間隔は記録していません。切った設定の費用は測っていないので、そこは自分で測ってください。\n\n試す順番は次のとおりです。\n\n1. 何も付けずに3回測り、合計トークンと `total_cost_usd` を控える\n2. ファイルを触らせないなら、`--tools \"\"` を足して3回測る\n3. 値が割れたら回数を増やし、最小と最大を両方控える\n4. MCP、設定、スラッシュコマンドは、一つずつ足して効きを見る"
    },
    {
      "condition": "9",
      "name": "メモ＋工程分け",
      "run": 2,
      "cost_usd": 0.201,
      "text": "# 「こんにちは」だけで入力20,404トークン。`claude -p` の前置きを外して測った\n\n「こんにちは。1語で返事して」と `claude -p` に送ったら、合計入力は20,404トークンでした。返事は一言なのに、です。差分は、こちらが書いていない前置き（ツール定義やシステムプロンプトなど）が占めています。設定を1つずつ外して、どこが重いのか測りました。\n\n測定は2026年10月8日、Macで、モデルはclaude-sonnet-5-5、Claude Codeは2.1.291です。実行は空のフォルダで、入力は毎回同じ文にしました。私の環境はMCPやskillsが多いので、数字は人によって違うはずです。\n\n## 測り方。input_tokens だけでは足りない\n\n```\nclaude -p \"こんにちは。1語で返事して\" --output-format json \\\n  | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\nJSON出力の `usage` にある `input_tokens` は、2か3しか出ません。残りはキャッシュ側の2つの欄に入るため、3つを足して初めて全体が見えます。上の例は足し算まで一度に行います（jq が必要です）。各設定は3回ずつ測りました。\n\n## 外して分かったこと\n\n| 追加したフラグ | 合計入力 |\n|---|---|\n| なし（既定） | 20,404（3回とも同じ） |\n| `--strict-mcp-config` | 18,711 |\n| `--setting-sources \"\"` | 17,078 |\n| `--disable-slash-commands` | 18,786と20,479にばらついた |\n| `--tools \"\"` | 2,184（3回中2回。1回は5,613） |\n| 上の4つ全部 | 2,011（3回とも同じ） |\n| 4つ全部と `--system-prompt` | 584（3回とも同じ） |\n\n一番効いたのはツールを切ることで、約1万8千トークン減りました。MCPを読まなくしても約1,700、設定を読まなくしても約3,300しか減りません。ツール定義そのものが、それだけ大きかったということです。\n\n4つ全部を切るのは、次のコマンドです。\n\n```\nclaude -p \"こんにちは。1語で返事して\" --output-format json \\\n  --tools \"\" --strict-mcp-config --setting-sources \"\" --disable-slash-commands\n```\n\nこれに `--system-prompt \"You are a helpful assistant.\"` を足すと584になりました。2,011との差から、Claude Code標準のシステムプロンプトは約1,400トークン分あったことになります。\n\nばらつきも出ました。`--tools \"\"` は1回だけ5,613になり、理由は分かりませんでした。`--disable-slash-commands` の20,479は、既定の20,404より大きい値です。1回測って判断していたら、どちらも見逃していたはずです。\n\n## 費用はどう変わるか。ツールを切る代償\n\n既定のままの `total_cost_usd` は、1回目が0.039ドル、2回目と3回目が0.005ドルでした。同じ前置きがキャッシュに乗ると、約8分の1です。1回目の前置きは `cache_creation_input_tokens` に、2回目以降は `cache_read_input_tokens` に入ります。先ほど足した欄のうちの2つです。\n\nそうなると、繰り返し実行するなら既定のままでも安くなります。減らす意味があるかは、絞った構成の費用を測っていないので、私には答えられません。手元で `total_cost_usd` を並べて確かめてください。\n\n減らす代償もあります。ツールを切ると、ファイルを読むことも書くこともできません。記事を書かせる、分類させるなど、文を渡して文を返してもらうだけの用途向けです。\n\n## 自分の環境で試す手順\n\n1. 既定で3回実行し、`usage` の3つの値を足します。これが基準値です。\n2. フラグを1つずつ足し、同じ入力で3回ずつ測ります。\n3. 3回の値は平均にせず、そのまま並べて記録します。最小と最大の幅が大きい設定は、数字が揺れる設定です。\n4. 同じ実行の `total_cost_usd` も控えます。1回目と2回目以降を分けて見ると、キャッシュの効き方が分かります。\n\n測る場所は、空のフォルダにそろえてください。別の場所で測ると、読み込まれる設定が変わって数字が合わなくなります。\n\nまず既定で1回、上の1行目のコマンドを実行してみてください。"
    },
    {
      "condition": "9",
      "name": "メモ＋工程分け",
      "run": 3,
      "cost_usd": 0.1974,
      "text": "# `claude -p` は一言で2万トークン使う。測って、減らす\n\nスクリプトから `claude -p` を何度も呼ぶなら、呼ぶたびに同じ前置きを背負います。空のフォルダで `claude -p \"こんにちは。1語で返事して\"` を実行したところ、既定のままで入力は合計20,404トークンでした。環境は Claude Code 2.1.291、モデルは claude-sonnet-5-5、測定日は2026年10月8日です。\n\n## 入力トークンは3つのフィールドの合計\n\n`--output-format json` を付けるとJSONが返り、`usage` に次の3つが入ります。\n\n```\ninput_tokens\ncache_creation_input_tokens\ncache_read_input_tokens\n```\n\n`input_tokens` は2とか3としか出ません。入力の大部分はあとの2つに入るので、3つを足さないと全体が見えません。合計は次の1行で出せます(jq を使います)。\n\n```\nclaude -p \"こんにちは。1語で返事して\" --output-format json | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\n```\n\n費用は同じJSONの `total_cost_usd` にあります。既定で3回続けたところ、1回目は0.039ドル、2回目と3回目は0.005ドルでした。毎回同じ前置き(システムプロンプトやツール定義)が、2回目から「キャッシュの読み出し側」に回ったためです。ただ、この環境では前置きが消えたわけではなく、合計は3回とも20,404のままでした。減らすには前置きそのものを小さくします。\n\n## 1つずつ切って比べる\n\n入力は毎回同じ一言に固定し、設定ごとに3回測りました。\n\n| 設定 | 合計入力トークン |\n|---|---|\n| 何も付けない(既定) | 20,404(3回とも同じ) |\n| `--tools \"\"` | 2,184が2回、5,613が1回 |\n| `--strict-mcp-config` | 18,711 |\n| `--setting-sources \"\"` | 17,078 |\n| `--disable-slash-commands` | 18,786と20,479(ばらついた) |\n| 上の4つを全部付ける | 2,011(3回とも同じ) |\n| 全部付けて `--system-prompt \"You are a helpful assistant.\"` | 584(3回とも同じ) |\n\n最後の行のコマンドは次のとおりです。\n\n```\nclaude -p \"こんにちは。1語で返事して\" --output-format json --tools \"\" --strict-mcp-config --setting-sources \"\" --disable-slash-commands --system-prompt \"You are a helpful assistant.\"\n```\n\n既定との差を見ると、MCPを切って約1,700、設定を切って約3,300しか減りません。ツールを切ると、2,184の回で約1万8千減りました。5,613が出た回でも約1万5千減っています。ツール定義だけで、入力の大半を占めていることになります。\n\n584は、Claude Code標準のシステムプロンプトを自分の一行に置き換えた結果です。2,011との差から、標準のシステムプロンプトは約1,400トークン分あったとわかります。\n\n## ばらつきと、切ったときに失うもの\n\n`--tools \"\"` で5,613が出た1回は、理由が分かっていません。`--disable-slash-commands` も回ごとに値が動きました。この2つは、1回測っただけで結論にしないほうが安全です。一方、全部切った2,011と、system-prompt まで置き換えた584は、3回とも同じ値でした。\n\n私の環境はMCPやskillsが多めなので、MCPや設定の削減幅はここでの値です。人によって違うはずです。\n\nツールを切ると、ファイルを読むことも書くこともできません。584という数字は、文章を書かせる、分類させるといった用途の話です。コードを読んで直させたい場合は使えません。ツールだけ残して他を切った組み合わせは測っていないので、その場合の合計は分かりません。\n\n## 自分の環境で測る手順\n\n1. 空のフォルダに移動し、入力は毎回同じ一言に固定します。\n2. 上の jq つきのコマンドを、フラグなしで3回実行して基準を取ります。\n3. `--tools \"\"`、`--strict-mcp-config`、`--setting-sources \"\"`、`--disable-slash-commands` を1つずつ付けて、同じ合計を3回ずつ出します。\n4. 値がぶれた設定は、平均にせず生の値を残します。私も5,613を平均に混ぜていたら、ツールの効果を小さく見積もっていたはずです。\n5. 4つを全部付けた回と、`--system-prompt` まで付けた回を測り、584に近い数字が出るか確かめます。\n\n次の一歩は、自分が実際に使うプロンプトを `--tools \"\"` 付きで1回流すことです。出力が崩れないかを見て、品質が保てるなら、トークンの大半を占めるツール定義を外せます。"
    },
    {
      "condition": "9",
      "name": "メモ＋工程分け",
      "run": 4,
      "cost_usd": 0.2031,
      "text": "# 「こんにちは」だけで約2万トークン。`claude -p` の入力を測って削る\n\n`claude -p` に「こんにちは。1語で返事して」と投げただけで、入力は20,404トークンでした。返事は1語です。2026年10月8日に筆者のMacで測りました。Claude Code 2.1.291、モデルは claude-sonnet-5-5、空のフォルダで実行し、設定ごとに3回ずつ測っています。\n\n## 測り方は、usageの3つを足す\n\n`--output-format json` を付けると、結果にusageが入ります。ただし `input_tokens` だけを見ると、2や3しか出ません。残りはキャッシュ側に入るためです。次の3つを足した値が、入力の全体になります。\n\n- `input_tokens`\n- `cache_creation_input_tokens`\n- `cache_read_input_tokens`\n\n```\nclaude -p \"こんにちは。1語で返事して\" --output-format json \\\n  | jq '.usage\n        | .input_tokens\n        + .cache_creation_input_tokens\n        + .cache_read_input_tokens'\n```\n\n費用を見る `total_cost_usd` も同じJSONに入っています。あわせて控えてください。\n\n作業ディレクトリは空のフォルダにします。CLAUDE.md やプロジェクト設定があると、既定値が変わるためです。\n\n## 結果は、ほぼツール側に集まっていた\n\n| 設定 | 合計入力トークン | 既定との差 |\n|---|---|---|\n| 何も付けない(既定) | 20,404(3回とも同じ) | |\n| `--strict-mcp-config` | 18,711 | 約1,700減 |\n| `--setting-sources \"\"` | 17,078 | 約3,300減 |\n| `--disable-slash-commands` | 18,786と20,479にばらついた | 一定しない |\n| `--tools \"\"` | 2,184(3回中2回)。1回は5,613 | 約18,200減 |\n| 上の4つを全部付ける | 2,011(3回とも同じ) | 約18,400減 |\n| 全部付けて `--system-prompt \"You are a helpful assistant.\"` | 584(3回とも同じ) | 約19,800減 |\n\n右の列はどれも既定との差なので、足し合わせられません。1,700と3,300と18,200を足すと既定の20,404を超えます。減る分が重なっているということです。\n\n`--tools \"\"` だけの2,184と、全部切った2,011の差は173しかありません。MCPの定義の多くが、すでにツール側に含まれていたのかもしれません。これは推測です。\n\n言えるのは、ツールを切ると桁が変わるということです。ただし、減ったのがツール定義そのものか、ツールに関する周辺の文面を含むのかは、分けて測っていません。\n\n最後の584は、標準のシステムプロンプトを自分の一行に置き換えた結果です。2,011との差から、標準のシステムプロンプトは約1,400トークン分と読めます。\n\n揺れた設定もありました。`--tools \"\"` で1回だけ5,613になった理由と、`--disable-slash-commands` がばらつく理由は分かっていません。\n\n## 切ると失うもの、費用への効き方\n\nツールを切ると、ファイルを読むことも書くこともできません。記事を書かせる、分類させるといった、ツールを使わない用途向けです。`--system-prompt` で標準のものを置き換えると応答が変わるかどうかは、筆者は検証していません。\n\n費用は、既定の1回目が0.039ドル、2回目と3回目が0.005ドルでした。同じ前置きがキャッシュに乗ると、約8分の1になっています。他の設定の費用は測っていません。\n\n## 自分の環境で試す手順\n\n1. 空のフォルダで、何も付けずに同じコマンドを3回続けて実行します。usageの3つの合計と `total_cost_usd` を毎回控え、1回目と2回目の費用を並べます。\n2. `--tools \"\"`、`--strict-mcp-config`、`--setting-sources \"\"`、`--disable-slash-commands` を1つずつ付けて、各3回測ります。3回分の値をすべて記録し、1回の結果だけで採用しないでください。\n3. 全部切った版を測ります。\n\n   ```\n   claude -p \"こんにちは。1語で返事して\" --output-format json \\\n     --tools \"\" --strict-mcp-config --setting-sources \"\" --disable-slash-commands\n   ```\n\n   さらに `--system-prompt \"You are a helpful assistant.\"` を足した版も測ります。\n4. 実際に使うタスクを、削る前と後で1回ずつ走らせ、出力を見比べます。機能が足りているか、応答が変わっていないかは、ここで確かめます。\n\n筆者の環境はMCPやskillsが多いので、数字は人によって違うはずです。最初の一歩は手順1です。今のスクリプトに先ほどのjqを足して、自分の既定値を出してください。"
    },
    {
      "condition": "9",
      "name": "メモ＋工程分け",
      "run": 5,
      "cost_usd": 0.1547,
      "text": "`claude -p` に「こんにちは。1語で返事して」と送るだけで、私の環境では入力が2万トークンを超えました。何が入っているのか、フラグを一つずつ切って確かめた記録です。\n\n## 3つの値を足して測る\n\n環境は Mac、モデルは claude-sonnet-5-5、Claude Code 2.1.291です。空のフォルダで、毎回同じ一言を3回ずつ送りました。\n\n```\nfor i in 1 2 3; do\n  claude -p \"こんにちは。1語で返事して\" --output-format json \\\n    | jq '.usage | .input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens'\ndone\n```\n\n`usage` の `input_tokens` だけを見ても、2か3しか出ません。残りはキャッシュ側に入るので、`cache_creation_input_tokens` と `cache_read_input_tokens` も足して初めて全体が見えます。jq がなければ、`jq ...` の代わりに次を使えます。\n\n```\npython3 -c 'import sys,json; u=json.load(sys.stdin)[\"usage\"]; print(sum(u[k] for k in (\"input_tokens\",\"cache_creation_input_tokens\",\"cache_read_input_tokens\")))'\n```\n\n何も付けない既定は、3回とも20,404トークンでした。\n\n## 一つずつ切ると、ツールが突出していた\n\n同じ入力にフラグを一つ付けて測った結果です。\n\n| 設定 | 合計入力トークン |\n|---|---|\n| 既定 | 20,404 |\n| `--tools \"\"`（ツールを全部切る） | 2,184 |\n| `--strict-mcp-config`（設定のMCPを読まない） | 18,711 |\n| `--setting-sources \"\"`（ユーザー設定とプロジェクト設定を読まない） | 17,078 |\n| `--disable-slash-commands`（skillsとスラッシュコマンドを切る） | 18,786 と 20,479 |\n\n効いたのはツールでした。MCPを切っても減るのは約1,700、設定を切っても約3,300です。ツールを切ると約1万8千トークン減るので、ツール関連の分がそれだけあったと見ています。ただし、これは「ツール定義そのもの」と言い切れる数字ではありません。\n\nばらつきもありました。`--tools \"\"` は3回中2回が2,184でしたが、1回だけ5,613に跳ねました。理由は分かりません。この1回を基準にすると、先の見積もりは約1万5千に変わります。スラッシュコマンドを切った場合も、18,786と20,479に割れました。1回の測定で優劣を決めると、この種の跳ねに引っかかります。\n\n私の環境はMCPやskillsが多めです。MCPと設定の行は、人によって大きく違うはずです。\n\n## 全部切ると584まで下がった\n\nツール、MCP、設定、スラッシュコマンドを全部切った実行例です。\n\n```\nclaude -p \"こんにちは。1語で返事して\" --output-format json \\\n  --tools \"\" --strict-mcp-config --setting-sources \"\" --disable-slash-commands\n```\n\n合計は2,011で、3回とも同じでした。ここに `--system-prompt \"You are a helpful assistant.\"` を足すと584です。差から見ると、Claude Code標準のシステムプロンプトが約1,400トークン分あったようです。なお `--system-prompt` は全部切った状態でしか測っていません。単独で付けた数字はありません。\n\n費用（`total_cost_usd`）は、既定の1回目が0.039ドル、2回目と3回目が0.005ドルでした。約8分の1です。同じ前置きがキャッシュに乗ったためと考えていますが、1回目と2回目でトークンの内訳を見比べてはいないので、確かめたい人は3つの値を並べてみてください。\n\n## 切ると失うもの、試す順番\n\nツールを切ると、ファイルの読み書きができなくなります。文章を書かせる、分類させるといった、ツールが要らない用途向けです。\n\n1. フラグなしで、3回測る。\n2. `--strict-mcp-config`、`--setting-sources \"\"`、`--disable-slash-commands`、`--tools \"\"` を一つずつ付けて、それぞれ3回測る。\n3. 既定との差が大きかった順に採用し、組み合わせて測り直す。\n4. 最後に `--system-prompt` を足す。\n\n私の環境の順位は、ツール、設定、MCPでした。あなたの表でツールの行の差が小さければ、差の大きい別の行を先に疑ってください。同じ設定の3回が割れたら、私の2,184と5,613のように、その行は平均せず「不安定」と記録して、回数を増やして測り直すのが安全です。"
    }
  ]
}