A running ShardStitch feed for rate limits, context-window shifts, quotas, and pricing changes across Claude, Codex, Copilot, Cursor, Gemini, and other AI coding tools.
Claude Code can stop because included session usage is exhausted, usage credits are unavailable, or a local/API error is being mistaken for a limit. Check the official usage state first.
Radar read: preserve git diff, terminal output, failed attempts, verified facts, and the next action before waiting for reset or switching tools.
CLAUDE.md and auto memory can carry useful context across sessions, but stale or poisoned memory still needs disk-backed verification before recovery.
Radar read: memory is a hint layer. Preserve verified files, tests, failed attempts, and decisions before letting memory steer the next session.
Remote agents can edit files, install packages, run commands, and keep working asynchronously. The safe handoff is the diff, logs, checks, and trust boundary.
Radar read: inspect the remote agent result like a contractor handoff before merging, retrying, or switching tools.
Tool migrations are not just install steps. The fragile part is carrying over changed files, failed attempts, verified checks, and the next action.
Radar read: move project truth through a tool-neutral packet before asking the new CLI to continue.
Q Developer IDE plugins have a transition path toward Kiro. In-progress transformations and debugging state should be captured before the tool boundary shifts.
Radar read: migrate verified project state, not just the assistant conversation.
Roo's archived project points to Cline and Zoo Code; Kilo publishes a separate Roo migration guide, while the former Roo team moved to Roomote. Their setup and migration paths differ.
Chat logs can contain code, internal URLs, project decisions, and sensitive prompts. Extract the useful recovery facts without making the transcript permanent memory.
Radar read: chat history is evidence. Local, minimized, trust-labeled recovery is the safer memory layer.
Local-provider failures can come from Roo, the model server, the endpoint, context size, or VRAM pressure. Check the local stack first, then preserve the work before retrying.
Use OpenAI's official troubleshooting order, distinguish a provider outage from one stale chat, and preserve unfinished work before clearing browser data.
OpenAI incidents can affect every conversation, one device, one feature, or only some users. Check official status before deleting a thread or repeatedly resending the same prompt.
Claude.ai, Claude Code, the API, Console, and individual models can fail independently. Match the affected surface before restarting or switching providers.
Access denied, unexpected 429, GitHub-dependent failures, and a stalled local session have different fixes. Preserve the project before retrying.
Recent incidents stopped conversations from loading, interrupted Codex requests, and disrupted Claude coding surfaces. The provider can fail while repository changes, test output, and project memory still survive.
Radar read: diagnose the outage, stop duplicate retries, separate verified evidence from interrupted-session claims, then continue in the same tool or cross the provider boundary with a clean recovery packet.
An API request can hang or fail after the agent has already modified files, printed useful diagnostics, or tried an approach that should not be repeated. Retrying blindly risks adding another branch of noise while the real state remains on disk.
Radar read: capture the diff, error output, failed attempts, verification status, and next smallest test first. Then resume in Roo Code (archived May 2026) or hand the packet to another tool.
Cursor documents separate monthly usage pools, with model choice affecting how quickly included usage is consumed. Current usage-based plans do not include Max Mode; it remains available on legacy request-based plans with separate pricing.
Radar read: when the editor warns that usage is running low, the useful response is not to keep feeding a bloated thread. Preserve the verified working state, then choose whether the next step belongs in Cursor, another tool, or a smaller fresh context.
Compaction helps a long Codex task continue, but it does not prove changed files, failed attempts, deploys, or verification state.
Radar read: use compaction for conversation continuity. Use a trust-labeled recovery packet for the actual working state.
Message length, attachments, current conversation length, tool use, reasoning effort, bursts, and usage-based billing all change how quickly a coding session hits the wall.
Radar read: a published cap is not the same as a safe continuation plan. Preserve the working state before the cutoff owns it.
Account-data export can be useful, but it is not a live recovery packet with git diff, changed files, failed attempts, decisions, verification state, and next action.
Radar read: owning chat history is not the same as owning the working state.
The hard part of switching AI coding tools is not opening another model. It is moving the useful state without stale transcript noise, hidden assumptions, or quota-window dependence.
Radar read: the portable unit should be the work, not the transcript.
Anthropic's public rate-limit docs now describe three usage tiers for the Claude API: Start, Build, and Scale. The docs also define request-per-minute, input-token-per-minute, and output-token-per-minute ceilings, with 429 responses and retry timing when an app exceeds capacity.
Higher Sonnet and Haiku capacity helps agentic workloads run longer. But for developers, the important lesson is still the same: API capacity and local working-state recovery are different problems.
OpenAI's current limits article distinguishes everyday chats, Thinking and Pro-model allowances, and separate Work or Codex usage. Check the current account and plan details rather than relying on old fixed-number summaries.
For developers, the exact number matters less than the interruption it creates. If the session stops in the middle of useful work, the local repo state needs to survive the cutoff.
Anthropic's Claude Code guidance says Pro and Max usage limits are shared across Claude and Claude Code. The practical effect for developers is simple: a long code session can consume the same plan capacity used by ordinary Claude work, and warning messages appear as remaining capacity drops.
That makes local recovery more important. If the coding session gets blocked, your next move should be reading the repo state from disk, not asking the blocked session to summarize itself.
Anthropic's paid-plan usage-credit docs say users can continue after included usage limits by switching to consumption-based pricing, while normal session limits still reset every five hours. That is useful, but it changes the decision point: keep paying inside the same bloated session, or restart clean with the useful state only.
For AI coding, the cost-control pattern is to recover from disk, trim stale context, and choose the right tool for the next step.
GitHub's model pricing docs explain that Copilot interactions consume input, output, and cached tokens, then convert that cost into AI Credits. Its individual-plan docs list monthly AI Credit allowances by plan, which means heavier agentic coding work has a measurable budget surface.
When model choice and token volume affect allowance burn, a clean handoff becomes more than convenience. It is a way to stop dragging expensive stale context through every next prompt.
GitHub's Copilot usage-limits page describes rate limiting as a mechanism to control request volume and preserve fair access. That matters for coding agents because a single task can trigger many requests across chat, edit, agent, CLI, and planning surfaces.
The safer workflow is to assume limits are part of the toolchain. Keep the working state portable so a limit does not become a project reset.
Google's developer program pricing page lists Gemini CLI request quotas as shared with Gemini Code Assist, with daily per-user limits varying by tier. Its Code Assist quota docs also say agent mode and Gemini CLI requests are combined, and a single prompt may result in multiple model requests.
For developers, the lesson is that switching from IDE agent mode to CLI is not always a fresh budget. A local handoff layer keeps the project state portable even when quota surfaces are shared.
Anthropic's help center separates usage limits from length limits: usage is the amount you can interact over time, while length is the working-memory limit of a conversation. For developers, those blend together when a long coding chat gets slow, expensive, or blocked mid-refactor.
The practical takeaway: a bloated session is not always best fixed by compacting in place. A clean restart prompt with git state, changed files, intent, and dependency notes can preserve the useful context while leaving the old thread behind.
GitHub's docs describe Copilot plans as including a monthly allowance of AI Credits, with the option to pay extra after that allowance is exhausted. That shifts the question from "does the tool work?" to "what does this coding session cost after the allowance runs out?"
That is exactly the moment a developer needs context portability. If one tool becomes expensive or constrained, the work should not be trapped inside it.
Usage-based billing changes developer behavior. If a coding session is burning through allowance while the chat is already bloated, the expensive move is staying trapped in that same thread.
The cheaper pattern is to preserve the real local state, restart clean, and choose the tool or model that makes sense for the next step instead of dragging stale context forward.
Google's quota docs list local codebase awareness with a 1,000,000 token context window. Its FAQ also says Gemini Code Assist IDE extensions and Gemini CLI stop serving requests for several individual tiers starting June 18, 2026, with Antigravity positioned as the migration path.
When a vendor changes quotas, tool names, or access paths, the safest workflow is to keep your local coding state portable.
Developers do not search for context-window details out of curiosity. They search when a session got too large, a tool started losing the thread, or a local coding agent needs a cleaner prompt. This Radar will keep a recurring watch on Codex CLI context behavior, plan changes, and handoff patterns.
ShardStitch's angle is simple: when the active AI session is bloated, the source of truth should be the repo on disk, not the tired chat.
Long AI coding sessions collect stale assumptions, abandoned branches, and old debugging paths. A good continuation prompt should not summarize everything. It should recover the current work: changed files, git diff, intent, dependency risk, and next action.
That is the core Radar thesis: every limit or context-window change pushes developers toward local, structured recovery.