I Edited the Intro Because I Realized I Buried The...  🔗 **Source:** [I Edited the Intro Because I Realized I Buried The...](https://twitter.com/trq212/status/2044653083817660431/?rw_tt_thread=True) > [!note]+ Document Notes > tags: [ai, claude-code, context-management] > author: Thariq > source: Twitter > reference: [https://twitter.com/trq212/status/2044653083817660431/?rw_tt_thread=True] > date created: > > # 🏷️ Title: Using Claude Code: Session Management & 1M Context > <!-- deep-read:sections start --> ## 🧭 Table of Contents - [📝 Summary](#-summary) - [📖 Main Content](#-main-content) - [🗒️ Notes](#️-notes) - [📚 References](#-references) - [🗣️ Paraphrase](#️-paraphrase) - [📰 Newsletter](#-newsletter) - [✅ Action Items](#-action-items) - [🧪 Hypotheses](#-hypotheses) - [📊 Methodology](#-methodology) - [❓ Questions](#-questions) - [🔮 Future Research](#-future-research) - [💡 Implications](#-implications) - [🧠 Learning Styles Assessment](#-learning-styles-assessment) - [📊 Accessibility Assessment](#-accessibility-assessment) - [🌍 DEIB Assessment](#-deib-assessment) - [✅ Logical Validity](#-logical-validity) - [🛡️ DARVO Analysis](#-darvo-analysis) - [🎯 Conclusion](#-conclusion) ### 🔗 References - Include links cited in or relevant to the article. ## 📝 Summary - What happened: The author explains how to manage Claude Code’s 1M-token context window to avoid context rot and pollution. - Why it matters: Poor session management degrades model performance and wastes tokens. - Key stakeholders: Developers using Claude Code, teams building with long-running agent workflows. - Risks and tradeoffs: Long sessions vs. accuracy; compaction vs. losing important details; convenience vs. manual control. - Bottom line: Treat every turn as a branch point and use rewind, new sessions, compaction, and subagents deliberately. ## 📖 Main Content - The 1M-token context window lets Claude Code run longer, more complex tasks, but attention spread causes “context rot” as sessions grow, especially beyond ~300–400k tokens. - The context window contains everything the model can “see”: system prompt, messages, tool calls/outputs, and files. When it fills, you must summarize and continue in a new window (“compaction”). - After each turn you can: continue, rewind, start a new session (/clear), compact, or spawn subagents. These are levers for context hygiene. - New sessions are recommended when you start a new task. For related, low-intelligence-sensitive tasks (e.g., writing docs for just-implemented code), reusing context can be cheaper and faster. - Rewind (Esc Esc or /rewind) is a hallmark of good practice: jump back to the last “clean” point (e.g., after reading files) and re-prompt with what you learned, instead of layering corrections on top of failed attempts. - Compaction vs fresh session: /compact asks Claude to summarize and keep what it thinks matters; /clear forces you to write a concise task brief yourself. Compaction is easier but lossy; /clear is work but precise. - Bad compacts happen when the model cannot predict your future direction—especially after long, meandering sessions (e.g., debugging one issue, then suddenly asking about a different warning that was dropped from the summary). - Subagents give fresh context windows to isolated sub-tasks whose intermediate steps you don’t need again, returning only a synthesized result (e.g., verifying work from a spec, reading another codebase’s auth flow, or writing docs). - You can also tighten auto-compaction by lowering the effective context window (e.g., 400k tokens) via configuration, trading raw length for better average performance. ### 🗒️ Notes - 1M context is a “double-edged sword”: powerful for autonomy and reliability, but vulnerable to clutter and distraction if unmanaged. - Context rot: as token count grows, attention diffuses; older and irrelevant content drags on performance and can mislead the model. - Context window contents: system prompt, conversation history, tools plus outputs, and read files all consume budget. - Hard cutoff: once the window fills, you must summarize and restart; compaction is essentially summarization-plus-continue. - Every turn is a branching point: - Continue: simplest, but accumulates more history and risk of rot. - Rewind: drop later messages, restart from a better anchor state. - Clear: start fresh with your own distilled brief. - Compact: have Claude summarize and keep going on top. - Subagents: push work into isolated contexts and only bring back final results. - Rule of thumb: new task → new session. Related follow-ups that benefit from existing context (like docs for recent code) can stay in the same session. - Rewind pattern: instead of “that didn’t work, now try X,” jump back to just after initial reads, and say “don’t use approach A because X; go straight to B.” - “Summarize from here” can create handoff notes across rewinds, acting like messages from “future Claude” to a previous step. - Compaction: - /compact: Claude decides what mattered; you can nudge with focus instructions (e.g., “focus on auth refactor, drop test debugging”). - /clear: you decide what matters, writing a short, explicit situation brief. - Bad compacts: - Occur when the session focus doesn’t match your next move (e.g., debugger summary missing a side warning you care about). - More likely when the model is already strained by large context. - Subagents: - Good when you only need the conclusion, not all intermediary outputs. - Use them for verification, cross-codebase study, or documentation tasks. - Config: you can effectively “shrink” your working context by setting a lower auto-compact threshold (e.g., 400k) to keep the model in a higher-performance regime. ## 📚 References - Original thread: [Using Claude Code: Session Management & 1M Context](https://twitter.com/trq212/status/2044653083817660431/?rw_tt_thread=True) - Claude Code docs (auto-compact setting): [CLAUDE_CODE_AUTO_COMPACT_WINDOW](https://code.claude.com/docs/en/settin) ## 🗣️ Paraphrase - Paragraph A: Claude Code’s huge context window enables long, complex autonomous work but introduces context rot, where too much accumulated information degrades performance and focus. - Paragraph B: Developers should treat each interaction as a decision point, choosing between continuing, rewinding, starting fresh, compacting, or using subagents to keep context relevant and reduce noise. ## 📰 Newsletter Claude Code’s 1M-token context window is powerful—but only if you manage it well. In this thread, Thariq outlines how context rot can derail long-running coding sessions and how to fight back with rewind, compaction, fresh sessions, and subagents. If you’re building WordPress tooling or workflows with Claude, this is a practical guide to keeping your agents sharp instead of drowning them in history. Worth a read before your next “infinite” coding session. ## ✅ Action Items #### DevRel - Document recommended Claude Code session patterns (continue vs rewind vs clear vs compact) with concrete IDE/CLI examples and share in talks. - Create hands-on workshops showing context rot in practice and how to mitigate it. - Publish quickstart templates for “good hygiene” sessions (debugging, refactors, doc generation). #### OSPO - Add guidance for AI-assisted coding flows that rely on long contexts, including safe defaults for auto-compaction. - Include context-management practices in training for compliance and security reviews. #### Community - Encourage maintainers to adopt rewind-first workflows in contributor docs for AI-assisted repositories. - Run office hours to help contributors design “clean context” prompts for repeated tasks. #### WordPress - Core: Define standard Claude Code workflows for triage, patch review, and regression analysis, using new sessions per task. - Core Performance: Experiment with lower auto-compact thresholds for performance-sensitive profiling tasks. - Core AI: Establish guardrails for how long-running agent sessions use compaction and subagents. - **Core Program Team:** Align on shared Claude Code usage patterns for cross-team projects and document them. - Playground: Offer example labs showing good vs bad context management in browser-based coding environments. - Community: Add meetup sessions focused on “running long AI sessions without losing the plot.” - Training: Integrate a module on managing 1M-token contexts into AI-in-WordPress curricula. - Marketing: Highlight “good AI session hygiene” as part of educational campaigns, not just model capabilities. - Support: Create KB entries showing how to recover from “model lost the thread” using rewind and clear. - Design: Provide UX hints or affordances in tools to encourage rewinding instead of piling on corrections. - Documentation: Add sections on session management and compaction for any official Claude-integrated workflows. - Photos / TV / Polyglots / Accessibility / Meta / CLI / Hosting / Tide / Openverse / Themes / Plugins: - Consider when long-running AI agents are used and document safe, context-aware workflows where relevant. #### The WPOCC - Programs: Fund experiments that compare long-running vs compacted AI workflows in open-source projects. - Projects: Host documentation sprints to capture best practices for AI session management. - Funding experiments: Support tooling that visualizes and explains context usage over time in AI-assisted dev. ### FAIR - Technical independence: Track and display local context size and compaction history for transparency. - Policies and covenants: Clarify acceptable use of long-running AI sessions, including logging and review. - Productized governance artifacts: Create templates describing how AI context is managed in critical systems. ## 🧪 Hypotheses - H1: Developers who frequently use rewind achieve higher task success rates than those who mainly stack corrective prompts. - H2: Setting auto-compact thresholds around 300–400k tokens improves average model accuracy over very long sessions. - H3: Manual “/clear and brief” resets produce more reliable outcomes than automatic compaction for direction-changing tasks. - H4: Subagents reduce token usage and confusion for tasks with large, disposable intermediate outputs. ### 📊 Methodology - Run A/B tests comparing rewind-first vs correction-first workflows across comparable coding tasks. - Measure task success, time to completion, and token usage with varying auto-compact thresholds. - Compare outcome quality between /compact and /clear for multi-stage tasks where the target changes midstream. - Log and analyze subagent vs non-subagent runs on documentation and cross-codebase analysis tasks. ### ❓ Questions - When does automatic compaction outperform human-written briefs, and vice versa? - How can tools visualize context rot so developers notice it before performance degrades? - What heuristics best predict when to spawn a subagent instead of continuing in the main session? ### 🔮 Future Research - Develop metrics for “context health” and integrate them into IDEs. - Explore adaptive compaction strategies that consider task type and recent interactions. - Investigate how different prompt structures interact with large contexts in coding environments. ### 💡 Implications - Practice: Teams should standardize simple rules (e.g., “new task → new session”) and teach rewind as the default fix. - Policy: Organizations may want guardrails on maximum context length or mandatory compaction for sensitive projects. - Security: Smaller, focused contexts lessen the chance of leaking unrelated secrets into prompts. - Education: Training should cover not just prompt writing but also long-context lifecycle management. - Funding: Tools that monitor and optimize context usage in agent workflows could be high-leverage investments. ### 🧠 Learning Styles Assessment - Reading level estimate: Likely late high-school / early college (Flesch–Kincaid around grade 11–12), owing to technical terminology and compound sentences. #### 👀 Visual learners - Present: Conceptual structure (branching decisions, multiple options). - Improve: Diagrams showing context growth, branching flows, and where rewind/compact apply. #### 🔊 Aural learners - Present: None explicitly. - Improve: Short audio or screencast walkthroughs of example sessions. #### 🗣️ Verbal learners - Present: Clear definitions (context window, context rot, compaction) and examples. - Improve: More analogies (e.g., “working memory” vs “notes”) and mini-glossary. #### 🧩 Kinesthetic learners - Present: Implied hands-on use of Claude Code. - Improve: Step-by-step labs: “Try this bad session; now fix it with rewind.” #### 🧠 Logical learners - Present: Cause-effect reasoning (longer context → rot; rot → worse performance). - Improve: Tables comparing options (continue/rewind/clear/compact/subagent) by pros and cons. #### 🧑‍🤝‍🧑 Social learners - Present: None explicit. - Improve: Pair exercises or group debugging labs using different session strategies. #### 🧘‍♀️ Solitary learners - Present: Thread format suits self-paced reading and experimentation. - Improve: Reflection prompts like “audit one of your last sessions and classify each turn.” #### 🌿 Naturalistic learners - Present: Minimal. - Improve: Analogies to ecosystems (overgrown vs pruned forests) for context maintenance. ### 📊 Accessibility Assessment #### Screen reader semantics - Present: Twitter thread structure with headings is limited; screenshots (“Image”) may lack alt text. - Improve: Provide full-text explanations for diagrams and ensure descriptive alt text. #### Keyboard navigation - Present: Default Twitter behavior. - Improve: For any reposts or docs, ensure logical focus order and skip links. #### Contrast and readability - Present: Standard Twitter contrast is generally acceptable. - Improve: In derivative docs, ensure at least 4.5:1 contrast and comfortable line spacing. #### Text resizing and reflow - Present: Twitter supports responsive layouts. - Improve: In long-form docs, test at 200% zoom and respect prefers-reduced-motion. #### Media and captions - Present: Images are referenced but not fully described. - Improve: Add captions or textual summaries for each diagram. #### Forms and interactions - Present: N/A beyond Twitter UI. - Improve: Any companion tools should ensure clear labels, large targets, and forgiving inputs. #### Standards reference - Map gaps and improvements to WCAG 2.2 AA, especially for images, contrast, and keyboard access. ### 🌍 DEIB Assessment #### Cultural breadth - Present: Content is technical and culturally neutral. - Improve: Include examples from diverse dev teams and global OSS communities. #### Inclusive language - Present: Generally neutral, no exclusionary terms. - Improve: Define jargon more explicitly for non-native speakers and newcomers. #### Neurodiversity support - Present: Chunked into clear sections and bullets. - Improve: More consistent headings, visual markers, and examples to reduce cognitive load. #### Representation - Present: No people depicted directly. - Improve: When adding visuals, ensure diverse representation with accurate alt text. #### Psychological safety - Present: Respectful, instructional tone. - Improve: Add guidance that mistakes in session management are normal and fixable. ### ✅ Logical Validity #### Strong reasoning - Inductive/causal: Long contexts often degrade performance (context rot) because attention diffuses; supported by internal observations around 300–400k tokens. - Practical reasoning: Every turn is a decision point, so explicit options (rewind, clear, compact, subagents) give users control over context quality. #### Fallacies - None obvious; claims are framed as observations and rules of thumb, not absolutes. #### Tone of voice - Tone: Pragmatic, friendly, and experience-based. Uses concrete coding examples (debugging, docs, auth refactor) to keep it grounded. ### 🛡️ DARVO Analysis - Deny: No denial or minimization of problems; context rot is acknowledged directly. - Attack: No attacks on users; instead, it guides them toward better habits. - Reverse victim/offender: Not present; the model’s limitations are stated without blame-shifting. ## 🎯 Conclusion - Bottom line: A 1M-token context window is powerful but fragile without good hygiene. Use rewind, fresh sessions, targeted compaction, and subagents to keep Claude Code focused, accurate, and efficient. - Practical next steps: Audit a few of your recent sessions, identify where you should have rewound or started fresh, and experiment with setting a lower auto-compact threshold to see how it affects your workflows. ## 🧱 Refactor Appendix (append after 🎯 Conclusion) ### 📚 Literature Split Pad - Purpose: Stage Konik CEE units that become per-source Literature notes. - Split level: **H3**. - Include verbatim quotes under 25 words and a [view highlight] link. ### [H1] 5–10-word present-tense claim > [!quote] [Using Claude Code: Session Management & 1M Context](https://twitter.com/trq212/status/2044653083817660431/?rw_tt_thread=True) by [[Thariq]] via [[Twitter]]. Published 2026-04-16. Accessed . > “The 1M context window is a double-edged sword.” Two lines: context and use. Cite data if relevant. [view highlight](https://twitter.com/trq212/status/2044653083817660431/?rw_tt_thread=True#H1) #xref #articleseed ID:rw_[MISSING] ### [H2] 5–10-word present-tense claim > [!quote] [Using Claude Code: Session Management & 1M Context](https://twitter.com/trq212/status/2044653083817660431/?rw_tt_thread=True) > “Context rot is the observation that model performance degrades as context grows.” Two lines: context and use. [view highlight](https://twitter.com/trq212/status/2044653083817660431/?rw_tt_thread=True#H2) #xref ID:rw_[MISSING] --- ### 🔖 Atomic Split Pad (Zettel Candidates) - Purpose: Promote reusable claims into Atomic notes. - Split level: **H4**. - Each item: one idea, present tense, specific, testable. #### [Z1] Rewind improves Claude Code session hygiene - Scope/condition in one line. - Pointer to page/time or dataset. - Links: [[Claude-Code-Context-Management]] [[AI-Session-Hygiene]] #### [Z2] Auto-compaction threshold affects model performance - Scope/condition in one line. - Pointer to page/time or dataset. - Links: [[Claude-Code-Context-Management]] [[Long-Context-Models]] --- ### ✏️ Fleeting Queue (Extract by Selection) - Purpose: Capture quick actions or sparks for Fleeting notes. - Extraction: **Select one line** → “Refactor: Extract selection to new note (content only).” - Keep each line short and self-contained. - [F1] Test rewind-first workflows in next Claude Code debugging session — context/https://twitter.com/trq212/status/2044653083817660431/?rw_tt_thread=True #fleeting #inbox - [F2] Document standard “new task → new session” rule for team — context/https://twitter.com/trq212/status/2044653083817660431/?rw_tt_thread=True #fleeting #inbox - [F3] Experiment with CLAUDE_CODE_AUTO_COMPACT_WINDOW=400000 in local setup — context/https://twitter.com/trq212/status/2044653083817660431/?rw_tt_thread=True #fleeting #inbox --- <!-- deep-read:sections end --> 📄 **Full text:** ![[Full Document Contents/Tweets/I Edited the Intro Because I Realized I Buried The....md|I Edited the Intro Because I Realized I Buried The... by Thariq]] ## Highlights - Unfortunately using context has a slight cost, which is often called context rot. Context rot is the observation that model performance degrades as context grows because attention gets spread across more tokens, and older, irrelevant content starts to distract from the current task. For our 1MM context model, we see some level of context rot happen around ~300-400k tokens, but it is highly dependent on the task- not a fast rule. ([View Highlight](https://read.readwise.io/read/01kpb2y7ax9cmrtkmrpa5k1ea1)) - Say you've just asked Claude to do something and it's finished, you’ve now got some information in your context (tool calls, tool outputs, your instructions) and you have a surprising number of options for what to do next: • **Continue** — send another message in the same session • **/rewind (esc esc)** — jump back to a previous message and try again from there • **/clear** — start a new session, usually with a brief you've distilled from what you just learned • **Compact** — summarize the session so far and keep going on top of the summary • **Subagents** — delegate the next chunk of work to an agent with its own clean context, and only pull its result back in ([View Highlight](https://read.readwise.io/read/01kpb2zt1r8p5cev9ktrcyrbb2)) - Our general rule of thumb is when you start a new task, you should also start a new session. ([View Highlight](https://read.readwise.io/read/01kpb30kxdd9b4mses5qqjwx0m)) - If I had to pick one habit that signals good context management, it’s rewin ([View Highlight](https://read.readwise.io/read/01kpb31c4kh41ar4fhspbhe8g2)) - Rewind is often the better approach to correction. For example, Claude reads five files, tries an approach, and it doesn't work. Your instinct may be to type "that didn't work, try X instead." but the better move is to rewind to just after the file reads, and re-prompt with what you learned. "Don't use approach A, the foo module doesn't expose that — go straight to B ([View Highlight](https://read.readwise.io/read/01kpb31zc9qkbs9vyth2aff94y)) - **Compact** asks the model to summarize the conversation so far, then replaces the history with that summary. It's lossy, you're trusting Claude to decide what mattered, but you didn't have to write anything yourself and Claude might be more thorough in including important learnings or files. You can also steer it by passing instructions (/compact focus on the auth refactor, drop the test deb ([View Highlight](https://read.readwise.io/read/01kpb32rvv0aspt8b0m128zvsv)) - With /clear *you* write down what matters ("we're refactoring the auth middleware, the constraint is X, the files that matter are A and B, we've ruled out approach Y") and start clean. It's more work, but the resulting context is what you decided was relevan ([View Highlight](https://read.readwise.io/read/01kpb33bv23w4dyzq8jckkb8ps)) - This is particularly difficult, because due to context rot, the model is at its least intelligent point when compacting. With one million context, you have more time to /compact proactively with a description of what you wan ([View Highlight](https://read.readwise.io/read/01kpb348j23p7tzrngryj9j7nr)) - The mental test we use: *will I need this tool output again, or just the conclusion?* ([View Highlight](https://read.readwise.io/read/01kpb34xz0fx88rxqfb9dwpm42))