Paano iwasan ang mahal na Claude Code session

Paano pigilan ang pagbagal at pagmahal ng mahabang Claude Code session

Bumabagal at nagiging mahal ang mahabang Claude Code session dahil muling ipinapadala ang buong context sa bawat turn, at patuloy na lumalaki ang context na ito. Ang solusyon ay ang pagpapanatili ng hygiene sa tamang pagkakasunod-sunod. Patakbuhin ang /context para makita ang laman ng window, i-cut ang mga item na binabayaran sa bawat request, pagkatapos ay gamitin ang /clear sa pagitan ng mga unrelated na task at /compact na may instruction sa loob ng isang mahabang task. Magtrabaho sa mga continuous stints, dahil ang cold prompt cache ay nagpapabago sa murang read para maging full re-write ng lahat ng sinabi mo.

Ang dahilan kung bakit tumatakbo ang meter ay ipinapaliwanag sa token meter sa likod ng isang agent session.

Basahin ang /context bago magbago ng kahit ano

Huwag hulaan ang laman ng window. Sasabihin ito sa iyo ng Claude Code.

Ipinapakita ng /context [all] ang kasalukuyang context usage bilang isang colored grid, kasama ang mga optimization suggestion para sa mga tool na may heavy context at memory bloat; pinalalawak ng all ang breakdown ng bawat item sa fullscreen mode. Basahin ang resulta bilang limang buckets.

• The system prompt. Ang sariling harness instructions ng Claude Code. Fixed ito para sa session.
• Tool definitions. Ang schema para sa bawat tool na pwedeng i-call ng agent, kasama ang bawat konektadong MCP (Model Context Protocol) server.
• Memory files. Ang CLAUDE.md at auto memory, na niloload sa simula ng session.
• Files and tool results. Bawat file na binasa, at lahat ng output ng iyong mga command.
• Message history. Ang iyong mga turns at ang mga reply nito.

Ang unang tatlo ay fixed tax, na binabayaran sa bawat request sa buong session. Ang huling dalawa ay lumalaki. Bawasan ang fixed tax nang isang beses sa simula; i-manage ang lumalaking bahagi nang tuluy-tuloy.

Dalawang string ang magsasabi kung 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.

Ang una ay isang hard limit, at tatanggihan ang request; ang katumbas na API (application programming interface) error ay Prompt is too long. Ang ikalawa ay isang compaction window, na maaaring mas mababa sa real context window ng model sa isang 1 million token model. Magtatagumpay pa rin ang mga request lampas dito, kaya ang isa ay warning lamang at hindi refusal.

Sa paid plan, idinaragdag ng /usage ang kabilang kalahati, na naglalagay ng flag sa mga behavior gaya ng long context o cache misses at iniuugnay ang recent usage sa mga indibidwal na skills, subagents, at MCP servers.

Ang CLAUDE.md ay isang permanenteng tax, kaya panatilihin itong lean

Ang iyong CLAUDE.md ay niloload sa context sa simula ng session at mananatili doon. Kung mayroon itong detalyadong deployment procedure, ang mga tokens na iyon ay kasama na kahit nagtatama ka lang ng typo sa isang test file. Ang guidance ng Anthropic ay isama lamang ang mga essentials at panatilihing under 200 lines ang file.

Ilipat ang mga procedure sa skills. Ang skill ay naglo-load lamang kapag tinawag, kaya ang workflow na ginagamit mo nang dalawang beses sa isang linggo ay walang gastos sa ibang araw. Ang skills ay may sariling budget pagkatapos ng compaction: ang mga bodies ay muling i-i-inject, na may limit na 5,000 tokens bawat skill at 25,000 sa kabuuan; ang pinakamatanda ang unang tinatanggal. Ang truncation ay pinapanatili ang simula ng file, kaya ilagay ang pinakamahalagang instructions sa itaas na bahagi ng SKILL.md.

Ang anumang matitira pagkatapos ng compaction ang magtatakda kung saan dapat ilagay ang isang instruction.

• Ang system prompt at output style ay hindi nagbabago, dahil hindi sila bahagi ng message history.
• Ang project-root CLAUDE.md, unscoped rules, at auto memory ay muling i-i-inject mula sa disk.
• Ang rule na may paths: frontmatter ay mawawala hanggang sa muling mabasa ang katugmang file.
• Ang isang nested CLAUDE.md sa isang subdirectory ay mawawala hanggang sa muling mabasa ang isang file sa subdirectory na iyon.
• Ang mga hooks ay walang epekto, dahil ang hook ay tumatakbo bilang code at hindi kailanman pumapasok sa context.

Kaya ang rule na kailangan mo ay dapat nasa project-root CLAUDE.md: Nililinis muna ng Claude Code ang mga lumang tool outputs bago mag-summarize, kaya ang mga instructions mula sa simula ng conversation ay maaaring mawala. I-edit ang memory gamit ang /memory. Hawak ng Claude Code ang kopya na niload nito sa simula ng session, kaya ang mid-session trim ay nagpapanatili sa prompt cache at hindi mag-a-apply hanggang sa susunod na /clear, /compact, o restart.

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

Mukhang magkapareho ang dalawang ito pero magkaiba ang gastos.

Ang /clear [name] ay nagsisimula ng bagong conversation na walang context. Hindi ito nagpapadala ng request, kaya wala itong gastos. Maglagay ng pangalan para ma-label ang nakaraang conversation sa /resume picker; ang /reset at /new ay mga alias. Gamitin ito agad kapag lumipat sa ibang task, dahil kung hindi, muling ipapadala at sisingilin ang lumang task sa bawat mensahe ng bagong task.

Ang /compact [instructions] ay nagpapalaya ng context habang itinutuloy ang parehong conversation: nino-summarize nito ang kasalukuyang history at pinapalitan ito. Gamitin ito sa loob ng isang mahabang task kung saan kailangan pa rin ang continuity.

Laging bigyan ng instruction ang /compact. Ang simpleng /compact ay gumagamit ng default prompt na hindi alam kung aling bahagi ng trabaho ang kailangan mo pa. Ang may instruction ay pinapanatili ang kailangang impormasyon:

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

Kung palagi mong ginagamit ang compaction sa parehong dahilan, maglagay ng standing instruction sa CLAUDE.md ng iyong project sa ilalim ng # Compact instructions heading. Sa isang bagong session, magpi-print ang /compact ng Not enough messages to compact., na ang ibig sabihin ay wala pang history.

Madalas malito sa dalawang gastos dito. Ang summarization request ay gumagamit ng iyong prefix, kaya binabasa nito ang existing cache sa halip na i-reprocess ang history, at ang karamihan sa oras nito ay napupunta sa pag-generate ng summary. Ang pag-compact ng malaking context ay isa pa ring malaking request, dahil ang conversation na sino-summarize ang nagsisilbing input. Ang susunod na turn pagkatapos ng compaction ay hindi ang mabagal na bahagi: muling binubuo ang cache para sa mas maikling prompt.

May dalawang mas murang command. Ang /rewind [description] ay nagbabalik ng code at conversation sa isang checkpoint; para sa path na gusto mo nang iwanan nang tuluyan, mas mabuti ito kaysa sa compacting, dahil pinuputol nito ang context pabalik sa isang prefix na naka-cache na. Ang /recap ay nagdadagdag ng summary bilang command output sa halip na palitan ang history, kaya nananatiling intact ang cached prefix.

Ang paulit-ulit na automatic compaction ay nagpi-print nito:

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

Nagtagumpay ang compaction, pero ang output ng isang file o tool ay muling nakapuno sa window nang ilang beses, kaya huminto ang Claude Code sa pag-retry. I-recover ito sa pamamagitan ng pagbabasa ng oversized file gamit ang line ranges, pagtakbo ng /compact na may focus na nagtatanggal sa malaking output, paglilipat ng trabahong iyon sa isang subagent, o /clear kung tapos na ang naunang conversation.

Ang mga MCP server ay may fixed overhead

Ang bawat MCP server na ikokonekta mo ay nagdaragdag ng overhead sa bawat request sa buong session. May gastos ito kahit hindi mo gamitin ang server.

Pinapagaan ito ng Claude Code. Ang mga MCP tool definition ay naka-defer by default, kaya pangalan lang ng mga tool ang pumapasok sa context hangga't hindi ginagamit ni Claude ang isang partikular na tool. Patakbuhin ang /context para makita ang tunay na cost ng iyong mga server, at /mcp disable <name> para i-drop ang server na hindi mo gagamitin ngayong araw. Kung patatakbo mo ang sarili mong MCP servers sa isang VPS, ang parehong logic ang maglilimita kung ilang tools ang dapat i-expose ng isang server.

Gawin ito sa simula ng session. Habang naka-defer ang mga definition, ang pag-connect o pag-disconnect ng server ay nagdadagdag lamang sa conversation, at mananatili ang cache. Kung ang mga definition naman ay naka-load sa prefix—dahil naka-off ang tool search o exempt ang server sa deferral—ang parehong pagbabago ay magiging sanhi para muling basahin ang lahat sa susunod na request.

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

Ang tool result ay nagsisilbing input, at ang input na ito ay muling ipinapadala sa bawat susunod na turn. Ang isang test run na naglalabas ng 20,000 tokens na output ay hindi isang beses lang na gastos: babayaran mo itong muli sa bawat turn hangga't nasa loob pa ito ng window.

I-filter ito sa source. Ang isang hook na nagbabawas sa test run para ipakita lang ang mga failure bago ito makita ni Claude ay magpapababa sa dami ng output mula sa isang wall patungo sa ilang daang tokens na lamang, sa turn na ito at sa bawat resend nito:

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

Ang mga hook ay hindi kailanman pumapasok sa context dahil tumatakbo ang mga ito bilang code. Gawin ito para sa anumang tool na ang output ay lumalagpas sa screen. Ang parehong logic ay applies din sa 3,000-line na file: hingin lamang ang line range na kailangan mo, dahil ang buong file ay mananatili sa window kapag dumating na ito.

Limit ang binabasa ng agent, at i-delegate ang mga maingay na gawain

Binabasa ng agent ang file kung ang prompt ay may pangalan ng file at sintomas. Kapag ang request ay para mag-ayos ng project, binabasa ng agent ang anumang ituring nitong relevant, at ang lahat ng pagbabasang ito ay mananatili sa window.

I-delegate ang mga verbose na gawain sa isang subagent. Ang pagpapatakbo ng test at pag-process ng log ay parehong kumakain ng real context; pinapanatili ng subagent ang output na iyon sa sarili nitong window at summary lang ang ibinabalik. Ang tradeoff: ang subagent ay bumubuo ng sariling cache na walang hits sa unang call, at gumagamit ng five-minute cache lifetime kahit naka-subscription. Ang delegation ay maaasahang paraan para protektahan ang iyong main context. Hindi nito laging nababawasan ang total tokens.

Ang cache clock: magtrabaho nang tuloy-tuloy

Ang prompt caching ang dahilan kung bakit mura ang resend: 0.1x ang base input rate para basahin ang prefix, kumpara sa 1.25x para isulat ito, o 2x para isulat ito sa loob ng one-hour lifetime. Bawat paggamit ay nagre-refresh ng entry nang walang extra cost, kaya ang clock ay nagsisimula mula sa huling paggamit.

Depende sa paraan ng iyong authentication kung anong lifetime ang makukuha mo, kaya mali ang pagsasabing "mag-eexpire ang cache mo pagkatapos ng limang minuto."

• Sa Claude subscription, awtomatikong humihiling ang Claude Code ng one-hour lifetime.
• Kapag lampas ka na sa limit ng iyong plan at gumagamit na ng usage credits, sisingilin ka para sa usage na iyon, kaya babalik ito sa limang minuto.
• Sa API key o cloud provider, mananatili ito sa limang minuto. Ang ENABLE_PROMPT_CACHING_1H=1 ay nag-o-opt in sa one-hour lifetime, at ang FORCE_PROMPT_CACHING_5M=1 ay pilit itong ibinabalik sa mas maikling oras.

Pareho lang ang payo tungkol sa rhythm: magtrabaho nang tuloy-tuloy, dahil ang idle gap na lampas sa lifetime ay magpapagawa sa susunod mong turn na isulat muli ang buong accumulated prefix. Ang isang detached Claude Code session sa tmux ay walang gastos habang idle, at ang warm cache ang nawawala kapag lumampas sa idle time.

May ilang aksyon na nagbubura sa cache habang nagtatrabaho ka pa: pagpapalit ng models, pagbabago ng effort level, pag-on ng fast mode, pag-connect o pag-disconnect ng MCP server, pag-enable o pag-disable ng plugin, pag-deny ng buong tool, pag-compact, at pag-upgrade ng Claude Code. Ang /model ang karaniwang sorpresa, dahil ang bawat model ay may sariling cache, kaya babasahin ng susunod na request ang buong history nang walang cache hits kahit pareho ang content.

Ang pag-edit ng files, pag-edit ng CLAUDE.md, pag-invoke ng skills at commands, pagtakbo ng /recap, pag-rewind, at pag-spawn ng subagent ay nagpapanatili sa cache. Nakapokus ito sa isang machine at isang directory, kaya ang dalawang session sa magkaibang directory ay hindi magagamit ang cache ng isa't isa.

Para makita kung gumagana ang caching, basahin ang current_usage. Ang cache_creation_input_tokens ay isinulat sa cache write rate; ang cache_read_input_tokens ay isinilbi sa halos isang ikasampu ng standard input rate. Ang mataas na read-to-creation ratio ay senyales na maayos ang takbo. Kung ang creation ay nananatiling mataas sa bawat turn, may nagbabago sa iyong prefix.

Masosolusyunan ba ito ng mas malaking context window?

Bahagi lang. Maraming kasalukuyang model ang sumusuporta sa 1 million token context window, at ang compaction ay gumagana sa parehong paraan kahit sa mas malaking limitasyon. Hindi nagbabago ang economics, dahil ang buong prompt ay ipinapadala pa rin at binubuwag pa rin sa bawat turn. Ang laki ng window ang nagtatakda kung kailan ka mapipilitang kumilos; ang hygiene ang nagtatakda ng gastos. Kung ang bill ang problema sa halip na ang ceiling, kung aling Claude plan ang angkop sa iyong workflow ang magpapasya kung dollars o plan allowance ang iyong ginagastos.

Magkaiba ang context editing at compaction sa API

Kung bumubuo ka ng sarili mong agent gamit ang Messages API, walang slash commands at kailangan mo itong i-implement nang manu-mano. May dalawang server-side feature para dito, at hindi sila pareho.

Context editing ang selektibong nagbubura ng partikular na content mula sa conversation history habang lumalaki ito. Pinapalitan ang bura na content ng placeholder text para malaman ni Claude na may tinanggal. Beta feature ito: i-send ang anthropic-beta: context-management-2025-06-27 at i-configure ang mga strategy sa ilalim ng context_management.edits. Ang clear_tool_uses_20250919 ay nagbubura ng tool results, at ang clear_thinking_20251015 ay nagma-manage ng thinking blocks. Ang trigger ay default sa 100,000 input tokens, ang keep ay sa huling 3 tool uses, at ang clear_tool_inputs ay sa false, kaya nananatili ang mga input at ang mga results lang ang tinatanggal.

Compaction ang gumagawa ng summary at pinapalitan ang buong conversation history gamit ito. Beta feature din ito: i-send 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 ang value ay dapat hindi bababa sa 50,000.

May isang handoff rule ang compaction na nagiging sanhi ng error sa mga agent. Ang response ay nagsisimula sa isang compaction content block na may summary, na sinusundan ng normal na text block. Kailangan mong i-pass muli ang block na iyon sa mga susunod na request, at pagkatapos ay tatanggalin ng API ang lahat ng content block bago ito. Sa praktikal na gamit: i-append ang buong response.content, hindi lang ang text.

Tinatawag ng dokumentasyon ng Anthropic ang server-side compaction bilang primaryang strategy para i-manage ang context sa mahahabang conversation, habang ang context editing naman ay para sa mas detalyadong kontrol sa mga tinatanggal. I-check muna ang model support. Ang kasalukuyang Opus, Sonnet, at Fable models ay may support para sa compaction; ang claude-haiku-4-5 ay wala, at ang compaction page ang naglalaman ng live list. Walang kinalaman ang alinman sa dalawang beta na ito sa /compact ng Claude Code, na inilalarawan sa dokumentasyon nito bilang isang one-off summarization request na ipinapadala ng client.

FAQ

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

Dahil ang buong conversation ay muling ipinapadala sa bawat turn, kaya ang isang linya na tanong sa isang session na bukas buong araw ay may kasama nang lahat ng data mula sa umaga. Pinapanatili itong mura ng prompt caching habang warm ang cache, sa 0.1x ng base input rate para sa pagbabasa; kapag hindi na nagamit ang cache sa isang turn, ang parehong prefix ay muling isinusulat sa 1.25x. Patakbuhin ang /context para makita kung ano ang nakapuno sa window, at basahin ang kung ano ang binabayaran sa isang Claude Code session para sa mekanismo nito.

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

Sinisimulan ng /clear ang isang bagong conversation na may empty context. Wala itong ipinapadalang request kaya walang gastos, at ito ang tamang piliin para sa mga hindi magkakaugnay na task. Pinapanatili ng /compact ang parehong conversation at pinapalitan ang history ng isang summary, kaya ito ang tamang piliin sa loob ng isang mahabang task. Bigyan ito ng focus, gaya ng sa /compact keep only the plan and the diff, dahil ang instruction ang nagpapasya kung ano ang mananatili.

Paano ko makikita kung ano ang gumagamit ng aking Claude Code context window?

Patakbuhin ang /context, o /context all para sa buong per-item breakdown. Ipinapakita nito ang system prompt, tool definitions, MCP servers, memory files, at history bilang isang colored grid, kasama ang mga suggestion para sa context-heavy tools at memory bloat. Sa isang paid plan, iniuugnay din ng /usage ang kamakailang usage sa mga indibidwal na skills, subagents, at MCP servers.

Dapat ko bang gamitin ang 1 million token context window sa halip na compaction?

Pinapatagal lamang ng mas malaking window ang problema sa halip na resolbahin ito. Ang ilang kasalukuyang models ay tumatakbo sa 1 million token context window, kabilang ang Opus 4.8 at Sonnet 5, at pareho ang gawi ng compaction doon. Ang bawat turn ay muling nagpapadala ng buong prompt at may bayad pa rin, kaya ang isang 400,000-token conversation ay mahal kahit kasya pa ito o hindi.

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

Ang context editing ay pinipiling burahin ang lumang content, karaniwan ay ang mga tool results, at nag-iiwan ng placeholder text kung saan ang bawat isa ay naroon para malaman ng Claude na tinanggal ito. Ang compaction ay gumagawa ng summary at pinapalitan ang buong history gamit ito. Tinatawag ng documentation ng Anthropic ang compaction bilang primary strategy para sa long-running conversations, at ang context editing naman ay bilang fine-grained option. Parehong beta ang mga ito na may sariling headers, at parehong hiwalay sa /compact ng Claude Code.