Claude Code: Paano Pabilisin at Paliitin ang Gastos

Paano maiwasang bumagal at magmahal ang mahabang Claude Code session

Bumabagal at nagiging magastos ang mahabang Claude Code session dahil ipinapadala muli sa bawat turn ang buong context, at patuloy na lumalaki ang context na iyon. Ang solusyon ay tamang pag-aayos sa nakatakdang pagkakasunod-sunod. Patakbuhin ang /context upang makita kung ano ang kumakain sa window, alisin ang mga item na binabayaran mo sa bawat request, pagkatapos ay gamitin ang /clear sa pagitan ng magkakaibang task at ang /compact na may instruction sa loob ng isang mahabang task. Magtrabaho sa tuloy-tuloy na mga stint dahil kapag cold ang prompt cache, nagiging full rewrite ng lahat ng sinabi mo ang isang murang read.

Ang paliwanag kung bakit patuloy na tumatakbo ang meter ay nasa token meter sa likod ng agent session.

Basahin ang /context bago ka magbago ng anuman

Huwag hulaan kung ano ang pumupuno sa context window. Sasabihin ito ng Claude Code.

Ipinapakita ng /context [all] ang kasalukuyang paggamit ng context bilang colored grid, kasama ang mga mungkahi sa optimization para sa mga tool na kumokonsumo ng maraming context at sa lumolobong memory; ipinapakita naman ng all ang breakdown ng bawat item sa fullscreen mode. Basahin ang resulta bilang limang bucket.

• System prompt. Sariling harness instructions ng Claude Code. Fixed ito para sa session.
• Tool definitions. Schema ng bawat tool na maaaring tawagin ng agent, kasama ang bawat nakakonektang MCP (Model Context Protocol) server.
• Memory files. CLAUDE.md at auto memory na nilo-load sa pagsisimula ng session.
• Files at tool results. Bawat file na binasa at lahat ng ipinabalik ng iyong mga command.
• Message history. Iyong mga turn at mga reply nito.

Fixed tax ang unang tatlo na binabayaran sa bawat request sa buong session. Lumalaki ang huling dalawa. Bawasan ang fixed tax nang isang beses sa simula; patuloy na pamahalaan ang lumalaking bahagi.

Dalawang string ang nagsasabi sa iyo na puno na ang window:

Context exceeds the 200k-token limit by 94k tokens — run /compact or /clear to continue.
Context is 94k tokens past the 200k-token compaction window — run /compact to reduce usage.

Hard limit ang una, kaya tinatanggihan ang request; ang katumbas na API (application programming interface) error ay Prompt is too long. Compaction window naman ang pangalawa. Maaari itong mas mababa sa aktuwal na context window ng isang 1 million token model. Matagumpay pa ring nagaganap ang mga request lampas dito, kaya warning ito at hindi refusal.

Sa paid plan, idinadagdag ng /usage ang kabilang kalahati. Tina-flag nito ang mga gawi gaya ng mahabang context o cache misses at iniuugnay ang kamakailang paggamit sa mga indibidwal na skill, subagent, at MCP server. Kung sinasabi nitong nagamit na ang allowance, ang kung aling limit window ang hinihintay mo ang tumutukoy kung makatutulong sa iyo ngayon ang pagbabawas ng context o kailangan mo ng ibang paraan upang maipagpatuloy ang trabaho.

Ang CLAUDE.md ay permanenteng gastos sa context, kaya panatilihin itong maikli

Ang iyong CLAUDE.md ay nilo-load sa context sa simula ng session at nananatili roon. Kung naglalaman ito ng detalyadong deployment procedure, naroon ang mga token na iyon habang nag-aayos ka ng typo sa isang test file. Ayon sa guidance ng Anthropic, isama lamang ang mahahalagang bagay at panatilihing wala pang 200 lines ang file.

Ilipat ang mga procedure sa skills. Nilo-load lamang ang isang skill kapag ini-invoke, kaya walang gastos ang workflow na ginagamit mo dalawang beses bawat linggo sa ibang mga araw. May sarili silang budget pagkatapos ng compaction: nire-re-inject ang mga body, na may cap na 5,000 tokens bawat skill at 25,000 sa kabuuan; unang inaalis ang pinakamatatanda. Pinananatili ng truncation ang simula ng file, kaya ilagay ang pinakamahahalagang instruction malapit sa itaas ng SKILL.md.

Ang nananatili pagkatapos ng compaction ang nagtatakda kung saan dapat ilagay ang isang instruction.

• Hindi nagbabago ang system prompt at output style dahil hindi bahagi ang mga ito ng message history.
• Mula sa disk, nire-re-inject ang project-root CLAUDE.md, mga unscoped rule, at auto memory.
• Nawawala ang isang rule na may paths: frontmatter hanggang sa muling mabasa ang katugmang file.
• Nawawala ang nested CLAUDE.md sa isang subdirectory hanggang sa muling mabasa ang isang file sa subdirectory na iyon.
• Hindi naaapektuhan ang hooks dahil tumatakbo ang hook bilang code at hindi kailanman pumapasok sa context.

Kaya ang isang rule na inaasahan mong laging magagamit ay dapat nasa project-root CLAUDE.md: inuuna ni Claude Code na alisin ang mas lumang tool outputs bago gumawa ng summary, kaya maaaring mawala ang mga instruction mula sa unang bahagi ng pag-uusap. I-edit ang memory gamit ang /memory. Hawak ni Claude Code ang kopyang nilo-load nito sa simula ng session, kaya pinananatili ng mid-session trim ang prompt cache at hindi ito nagkakabisa hanggang sa susunod na /clear, /compact, o restart. Isa lamang ang context loss sa mga dahilan kung bakit hindi na sinusunod ang isang rule. Kaya kapag malinaw na nasa window pa rin ang rule ngunit hindi pa rin ito sinusunod, suriin muna ang iba pang posibleng dahilan bago ito muling isulat.

/clear sa pagitan ng mga task, /compact sa loob ng iisang task

Mukhang mapagpapalit ang dalawang ito, pero malaki ang pagkakaiba ng gastos.

/clear [name] ang nagsisimula ng bagong conversation na walang laman ang context. Wala itong ipinapadalang request, kaya wala itong gastos. Magpasa ng pangalan upang lagyan ng label ang nakaraang conversation sa picker ng /resume; mga alias ang /reset at /new. Gamitin ito sa sandaling lumipat ka sa hindi kaugnay na task, dahil kung hindi, ipapadala at sisingilin muli ang lumang task sa bawat message ng bagong task.

/compact [instructions] ang nagpapalaya ng context habang ipinagpapatuloy ang parehong conversation: sinusuma nito ang history hanggang sa puntong iyon at pinapalitan ito. Gamitin ito sa loob ng isang mahabang task kung kailangan mo pa rin ng continuity.

Laging bigyan ng instruction ang /compact. Ang walang laman na /compact ay nagsusuma batay sa default prompt na hindi alam kung aling bahagi ng gawain ang kailangan mo pa. Kapag may instruction, napapanatili nito ang:

/compact focus on the auth bug fix
/compact keep only the plan and the diff

Kung pareho ang dahilan ng pag-compact mo sa bawat pagkakataon, maglagay ng standing instruction sa CLAUDE.md ng iyong project, sa ilalim ng heading na # Compact instructions. Sa bagong session, ipinapakita ng /compact ang Not enough messages to compact., na nangangahulugan lamang na wala pang history.

Dalawang magkaibang gastos ang madalas napagkakamalan dito. Ibinabahagi ng summarization request ang iyong prefix, kaya binabasa nito ang kasalukuyang cache sa halip na iproseso muli ang history, at karamihan ng oras nito ay ginugugol sa pag-generate ng summary. Malaki pa rin ang request kapag nag-compact ng malaking context, dahil input ang conversation na sinusuma. Hindi ang turn pagkatapos ng compaction ang mabagal na bahagi: nire-rebuild nito ang cache para sa mas maikling prompt.

May dalawang mas murang command. Binabalik ng /rewind [description] ang code at conversation sa isang checkpoint; para sa path na gusto mong tuluyang i-abandon, mas mainam ito kaysa mag-compact dahil nagta-truncate ito pabalik sa prefix na naka-cache na. Ina-append naman ng /recap ang summary bilang command output sa halip na palitan ang history, kaya nananatiling buo ang cached prefix.

Kapag paulit-ulit na nagti-trigger ang automatic compaction, ito ang ipinapakita:

Autocompact is thrashing: the context refilled to the limit...

Nagtagumpay ang compaction, pero ilang beses na muling pinuno ng isang file o tool output ang window nang sunod-sunod, kaya tumigil ang Claude Code sa pag-retry. Para makabawi, basahin ang malaking file gamit ang mga line range, patakbuhin ang /compact na may focus na nag-aalis ng malaking output, ilipat ang gawain sa isang subagent, o gamitin ang /clear kung tapos na ang naunang conversation.

Ang MCP servers ay fixed overhead

Bawat MCP server na ikinokonekta mo ay nadaragdag sa bawat request sa buong session. Magbabayad ka kahit hindi mo ito gamitin.

Pinapagaan ito ng Claude Code. Bilang default, deferred ang mga MCP tool definition, kaya mga tool name lamang ang napupunta sa context hanggang gumamit si Claude ng isang partikular na tool. Patakbuhin ang /context para makita ang aktuwal na cost ng iyong mga server, at ang /mcp disable <name> para alisin ang server na hindi mo gagamitin ngayong araw. Kung nagpapatakbo ka ng sarili mong MCP server sa isang VPS, nililimitahan din ng parehong kalkulasyon kung ilang tool ang dapat i-expose ng isang server.

Gawin ito sa simula ng session. Habang deferred ang mga definition, ang pagkonekta o pag-disconnect ng server ay nagdaragdag lamang sa conversation, at nananatili ang cache. Kapag sa prefix naman nilo-load ang mga definition dahil naka-off ang tool search o exempt ang isang server sa deferral, kailangan ng parehong pagbabago na basahin muli ang lahat sa susunod na request.

I-filter ang verbose tool output bago ito pumasok sa context

Ang tool result ay input, at ipinapadala muli ang input sa bawat susunod na turn. Ang test run na naglalabas ng 20,000 token na output ay hindi isang beses lang na gastos: magbabayad ka ulit para rito sa bawat turn hanggang sa mawala ito sa window.

Mag-filter sa source. Kapag binawasan ng isang hook ang test run at iniwan lamang ang mga failure bago ito makita ni Claude, nagiging ilang daang token na lang ang napakahabang output na iyon, sa turn na ito at sa bawat muling pagpapadala nito:

npm test 2>&1 | grep -E "FAIL|Error:" | head -40

Hindi pumapasok mismo sa context ang mga hook dahil tumatakbo ang mga ito bilang code. Gawin ito para sa anumang tool na ang output ay lumampas sa isang screen. Saklaw din ng parehong logic ang isang file na may 3,000 linya: hingin ang line range na kailangan mo, dahil mananatili sa window ang buong file kapag dumating na ito.

Saklawin kung ano ang binabasa ng agent, at i-delegate ang maingay na gawain

Ang prompt na tumutukoy sa file at sintomas ay nagbabasa sa file na iyon. Ang bukas na request na ayusin ang project ay nagbabasa ng anumang itinuturing ng agent na may kaugnayan, at nananatili sa window ang bawat pagbabasang iyon.

I-delegate ang verbose na gawain sa isang subagent. Parehong kumokonsumo ng aktuwal na context ang test runs at pagproseso ng logs; pinananatili ng subagent ang output sa sarili nitong window at nagbabalik lamang ng buod. Ang kapalit nito: gumagawa ang subagent ng sarili nitong cache na walang hits sa unang tawag, at ginagamit nito ang limang-minutong cache lifetime kahit naka-subscription. Maaasahang pinoprotektahan ng delegation ang pangunahing context. Hindi nito palaging binabawasan ang kabuuang tokens.

Ang cache clock: magtrabaho sa magkakasunod na stint

Ang prompt caching ang nagpapamura sa muling pagpapadala: 0.1x ng base input rate para basahin ang prefix, kumpara sa 1.25x para isulat ito, o 2x para isulat ito kapag one-hour ang lifetime. Bawat paggamit ay nagre-refresh sa entry nang walang dagdag na bayad, kaya nagsisimula ang clock sa huling paggamit. Ipinapakita ng mga multiplier na ito ang anyo ng bill pero hindi ang kabuuang halaga, kaya itambal ang mga ito sa aktuwal na halaga ng isang milyong token upang gawing halaga sa dollars ang buong context window.

Depende sa paraan ng iyong authentication kung aling lifetime ang makukuha mo. Dito nagkakamali ang pangkalahatang pahayag na “mag-e-expire ang cache mo pagkalipas ng limang minuto.”

• Sa Claude subscription, awtomatikong hinihiling ng Claude Code ang one-hour lifetime.
• Kapag lampas ka na sa limit ng iyong plan at gumagamit ng usage credits, sisingilin ka para sa paggamit na iyon, kaya babalik ito sa five minutes.
• Sa API key o cloud provider, nananatili itong five minutes. Nag-o-opt in ang ENABLE_PROMPT_CACHING_1H=1 sa one-hour lifetime, at ibinabalik ito ng FORCE_PROMPT_CACHING_5M=1 sa five minutes.

Pareho pa rin ang payo sa ritmo: magtrabaho sa magkakasunod na stint, dahil kapag lumampas sa lifetime ang idle gap, kailangang isulat muli ng susunod mong turn ang buong naipong prefix. Walang gastos habang idle ang isang detached Claude Code session sa tmux, at ang warm cache ang nawawala kapalit ng idle time.

May ilang action na nagtatapon sa cache kahit nagtatrabaho ka pa: pagpapalit ng model, pagbabago ng effort level, pag-on ng fast mode, pagkonekta o pagdiskonekta ng MCP server, pag-enable o pag-disable ng plugin, pagtanggi sa isang buong tool, pag-compact, at pag-upgrade ng Claude Code. Karaniwang sorpresa ang /model, dahil may sariling cache ang bawat model. Dahil dito, binabasa ng susunod na request ang buong history nang walang cache hit kahit pareho ang content. Sisingilin ang muling pagbasa batay sa rate ng destination model, kaya kapag lumipat ka sa Fable sa kalagitnaan ng session, sisingilin ang buong naipong history sa inilathalang input rate ng Fable 5.

Hindi nakakaapekto sa cache ang pag-edit ng files, pag-edit ng CLAUDE.md, pag-invoke ng skills at commands, pagpapatakbo ng /recap, pag-rewind, at pag-spawn ng subagent. Saklaw nito ang isang machine at isang directory lamang, kaya hindi nagagamit ng dalawang session sa magkaibang directory ang cache ng isa’t isa. Nakabatay ang saklaw na ito sa CLI, hindi sa account mo, kaya walang napupunta rito sa Claude desktop app, na sa Linux ay hiwalay na beta install kasabay ng CLI.

Para makita kung gumagana ang caching, basahin ang current_usage. Isinulat ang cache_creation_input_tokens gamit ang cache write rate; inihatid ang cache_read_input_tokens sa humigit-kumulang ikasampu ng standard input rate. Malusog na senyales ang mataas na read-to-creation ratio. Kung nananatiling mataas ang creation sa bawat turn, may bahagi ng prefix mo na patuloy na nagbabago.

Naaayos ba ito ng mas malaking context window?

Bahagya. Sinusuportahan ng ilang kasalukuyang model ang 1 million token na context window, at pareho pa rin ang paraan ng compaction sa mas malaking limitasyon. Hindi nagbabago ang economics, dahil muling ipinapadala ang buong prompt at sinisingil pa rin sa bawat turn. Tinutukoy ng mas malaking window kung kailan ka mapipilitang kumilos; ang maayos na pamamahala ng context ang tumutukoy sa gastos. Kung ang problema ay ang bill at hindi ang ceiling, angkop na Claude plan sa paraan ng pagtatrabaho mo ang magpapasya kung dollars o plan allowance ang ginagamit mo.

Magkaiba ang context editing at compaction sa API

Kung ikaw ang gumagawa ng sarili mong agent sa Messages API, walang slash command at ikaw mismo ang dapat magpatupad nito. Isama na sa simula ang oras at resources para sa gawaing ito, dahil walang libreng tier ang API bukod sa maliit na signup credit, kaya buong sinisingil ang bawat turn ng hindi na-trim na history. Ang provider na pipiliin mo ang nagtatakda ng kalkulasyong ito bago pa mangyari ang anumang pag-trim. Kung hindi pa pinal ang pagpili, kalkulahin ang parehong workload sa dalawang API sa halip na ikumpara lamang ang nakalistang per-token rates. Dalawang server-side feature ang gumagawa nito, at magkaiba ang mga ito.

Context editing ang piling naglilinis ng partikular na content mula sa conversation history habang lumalaki ito. Pinapalitan nito ang bawat nilinis na resulta ng placeholder text upang malaman ni Claude na may inalis. Beta ito: ipadala ang anthropic-beta: context-management-2025-06-27 at i-configure ang mga strategy sa ilalim ng context_management.edits. Nililinis ng clear_tool_uses_20250919 ang tool results, at mina-manage ng clear_thinking_20251015 ang thinking blocks. Ang trigger nito ay may default na 100,000 input tokens, ang keep ay sa huling 3 tool use, at ang clear_tool_inputs ay sa false. Dahil dito, nananatili ang mga input at ang mga resulta lamang ang nililinis.

Ang compaction ay gumagawa ng summary at pinapalitan nito ang buong conversation history. Beta rin ito: ipadala ang anthropic-beta: compact-2026-01-12 at gamitin ang edit type na compact_20260112. Ang default na trigger ay {"type": "input_tokens", "value": 150000}, at dapat hindi bababa sa 50,000 ang value.

May isang handoff rule ang compaction na maaaring hindi mapansin at makasira sa mga agent. Nagsisimula ang response sa compaction content block na naglalaman ng summary, kasunod ang normal na text block. Dapat mong ipasa muli ang block na iyon sa mga susunod na request. Pagkatapos, inaalis ng API ang lahat ng content block bago nito. Sa aktuwal na paggamit, idagdag ang buong response.content, hindi lamang ang text.

Ayon sa documentation ng Anthropic, ang server-side compaction ang pangunahing strategy para sa pag-manage ng context sa mahahabang conversation. Ang context editing naman ang opsyon para sa mas pinong kontrol sa content na lilinisin. Suriin muna ang model support. Sinusuportahan ng kasalukuyang Opus, Sonnet at Fable models ang compaction; hindi ito sinusuportahan ng claude-haiku-4-5, at nasa compaction page ang kasalukuyang listahan. Wala sa dalawang beta ang kumokontrol sa sariling /compact ng Claude Code. Inilalarawan ito ng documentation nito bilang isang one-off summarization request na ipinapadala ng client.

FAQ

Bakit bumabagal at nagiging mas mahal ang Claude Code session habang tumatagal ito?

Dahil ipinapadala muli ang buong conversation sa bawat turn. Kaya ang isang tanong na isang linya lang sa session na bukas buong araw ay kasama ang buong conversation ng araw na iyon. Pinapanatiling mura ito ng prompt caching habang warm ang cache, sa 0.1x ng base input rate para sa read. Kapag nag-miss sa cache ang isang turn, isinusulat muli ang parehong prefix sa 1.25x. Patakbuhin ang /context para makita kung ano ang kumokonsumo sa window, at basahin ang kung paano sinisingil ang isang Claude Code session para sa mekanismo.

Ano ang pagkakaiba ng /clear at /compact sa Claude Code?

/clear ay nagsisimula ng bagong conversation na walang laman ang context. Wala itong ipinapadalang request, kaya walang gastos, at ito ang tamang piliin sa pagitan ng magkakaibang task. /compact ay nagpapanatili ng parehong conversation at pinapalitan ang history ng summary, kaya ito ang tamang piliin sa loob ng isang mahabang task. Bigyan ito ng focus, gaya ng /compact keep only the plan and the diff, dahil tinutukoy ng instruction kung ano ang mananatili.

Paano ko makikita kung ano ang kumokonsumo sa Claude Code context window ko?

Patakbuhin ang /context, o ang /context all para sa kumpletong breakdown bawat item. Ipinapakita nito ang system prompt, tool definitions, MCP servers, memory files, at history bilang colored grid, kasama ang mga mungkahi para sa context-heavy tools at memory bloat. Sa isang paid plan, iniuugnay rin ng /usage ang kamakailang usage sa mga indibidwal na skill, subagent, at MCP server.

Dapat ba akong gumamit ng 1 million token context window sa halip na mag-compact?

Inaantala lamang ng mas malaking window ang problema sa halip na lutasin ito. Ilang kasalukuyang model ang gumagamit ng 1 million token context window, kabilang ang Opus 4.8 at Sonnet 5, at pareho pa rin ang paggana ng compaction doon. Ipinapadala pa rin muli ang buong prompt sa bawat turn at sinisingil pa rin ito, kaya mahal ang isang 400,000-token conversation kahit kasya ito.

Ano ang pagkakaiba ng context editing at compaction sa Claude API?

Pinipili ng context editing ang mga lumang content na aalisin, na karamihan ay tool results, at nag-iiwan ng placeholder text kung saan naroon ang bawat isa upang malaman ni Claude na inalis ang mga ito. Gumagawa ang compaction ng summary at pinapalitan nito ang buong history. Tinatawag ng documentation ng Anthropic ang compaction na pangunahing strategy para sa mahahabang conversation at inilalarawan ang context editing bilang mas pinong option. Pareho silang beta na may sariling header, at parehong hiwalay sa /compact ng Claude Code.