Lesson 5 – Agentic Coding using Claude Code

Understanding the Core Limitations

Agentic coding tools represent a significant leap in how developers interact with artificial intelligence, moving beyond simple chat interfaces into collaborative partners that can directly manipulate files, execute terminal commands, and manage complex project logic. However, this power comes with architectural constraints that every developer must understand to use them effectively. The context window serves as the foundational bottleneck in this architecture, defining the boundary of what the model can "see" at any given moment. When working with a tool like Claude Code, understanding this window is not merely a technical curiosity; it is the dividing line between a productive coding session and a frustrating spiral of hallucinations, cost overruns, and degraded output. The context window represents the model's working memory, and like any memory system, it has a finite capacity that fills up rapidly during active development conversations.

The technical ecosystem around large language models has normalized the concept of massive context windows, often marketing 200k token capacities as a solution to memory limitations. But raw capacity and usable context are fundamentally different things. As the conversation grows with each back-and-forth exchange, the window fills with the system prompt, tool definitions, conversation history, tool outputs, and the files being actively edited. This accumulation happens silently in the background, and without active management, performance degradation occurs well before the absolute limit is reached. The lesson from CampusX establishes this grounding immediately, addressing not just the abstract concept of context but the practical implications of hitting these walls during real work.

How the Context Window Fills Internally

A common misconception among developers is that the context window only contains the chat messages they see on screen. In reality, the internal structure of a Claude Code session is far more complex. The system prompt, which defines the agent's personality, capabilities, operational rules, and safety guidelines, consumes a significant fixed overhead with every single API call. Tool definitions for file reading, writing, editing, and terminal execution also occupy permanent space, as the model needs to know the exact schemas to generate valid function calls. On top of this static consumption, the dynamic elements rapidly accumulate. Every file that is read into the session, every terminal output that is returned to the model, and every previous exchange between the user and the assistant is appended to the context.

This architecture means that even a moderately complex debugging session can exhaust tens of thousands of tokens extremely quickly. A developer might ask the agent to fix a bug in a 2,000-line file; the file is read into context, the model analyzes it, produces a fix, and the diff is applied. If the fix does not work the first time, the entire file content remains in the history along with the failed attempt and the error output. Each iteration compounds the problem, and without deliberate intervention, the context window balloons. CampusX's breakdown of this internal filling mechanism is crucial for developers who often blame the model for "getting dumber" over time, when in reality, the model is simply drowning in an overwhelming amount of data, losing its ability to attend to the most relevant parts of the task.

The Cost and Quality Impact

The dual consequences of a bloated context window are financial and qualitative. From a cost perspective, every token passed into the model is billed, regardless of whether that token contains essential reasoning or stale conversation history. As the conversation grows, each successive API call becomes more expensive, creating a compounding cost curve that can make extended sessions surprisingly costly. The video emphasizes this practical reality, pointing out that developers who ignore context management are essentially throwing money away. The model processes the entire context, including the parts that are no longer relevant, and the user pays for that processing.

But the quality impact is arguably even more critical. As the context approaches saturation, the model's ability to maintain focus degrades. It may begin to ignore instructions provided at the beginning of the session, overlook errors that were documented earlier, or produce hallucinated code that references variables or functions that do not exist. This is not a flaw in the model's fundamental intelligence; it is a direct consequence of the attention mechanism being spread too thin across too many tokens. The "lost in the middle" phenomenon, where models struggle to effectively use information placed in the center of a long context, becomes more pronounced. A developer experiencing these symptoms in a standard chat might simply start a new session, but in an agentic coding environment where the tool has performed complex refactoring across multiple files, the instinct to preserve history must be balanced against the need for clean context.

Compaction as a Primary Strategy

To address the inevitable growth of conversation history, Claude Code implements an auto-compaction mechanism. This feature acts as an automatic summarization engine that triggers when the context window reaches a certain threshold. Instead of simply truncating the oldest messages, which would result in catastrophic memory loss, the system attempts to intelligently summarize the conversation so far, preserving the key decisions, code patterns, and unresolved issues while discarding the verbatim back-and-forth. CampusX explains this process in depth, detailing how the model condenses the existing transcript into a dense summary that is then placed at the beginning of a new logical session, followed by the continuation of the task.

The auto-compaction approach is effective but not perfect. Summarization inherently loses information, particularly the subtle nuances of debugging or the specific context around a failed approach. A summarized version of an hour of work might capture that "the user is building a REST API and resolved an authentication bug by switching to JWT tokens," but it may lose the granular details of which specific files were modified and why a particular library version was chosen. For this reason, the video also explores the manual compaction trigger, `/compact`, which allows developers to proactively summarize the session at a logical stopping point rather than waiting for the automatic threshold. Understanding when and how to compact is presented as a fundamental skill for power users of agentic coding tools.

Session Splitting and Sub-Agent Architecture

One of the most actionable techniques discussed is the deliberate splitting of work into separate sessions. While it may seem counterintuitive to break apart a workflow that could theoretically run indefinitely, the lesson makes clear that autonomous agents perform best when given bounded, specific tasks with a clean context slate. Rather than attempting to build an entire application in a single monolithic session, developers should break down their work into discrete milestones. Completing the data layer, starting a new session, then moving to the API routes, starting another session, and finishing with the front-end components allows each phase to operate with the full attention of the model without the noise of previous implementation details.

Sub-agents provide an even more powerful mechanism for maintaining context hygiene. Claude Code can spawn isolated sub-agents to handle specific subtasks, each with its own clean context window. The parent agent acts as an orchestrator, defining the task for the sub-agent, receiving the completed output, and integrating it into the main codebase. This architectural pattern mirrors how human engineering teams operate, with specialists working on isolated components that are later merged. The sub-agent operates without any knowledge of the broader project history, focusing entirely on the specific task assigned to it. This isolation prevents the context pollution that plagues long-running sessions and allows for parallel mental models where each agent can approach a fresh problem without being influenced by the biases or errors of previous steps.

Terminal Interface and Operational Best Practices

The choice of interface may seem like a minor detail, but the video makes a compelling case for why the terminal remains the preferred environment for serious agentic coding work. Graphical user interfaces for AI agents add layers of abstraction that obscure the very resource management that developers need to monitor. The terminal provides direct visibility into what is happening under the hood, including token consumption, context usage, and the exact commands being executed. A slash command like `/context` becomes a dashboard for session health, showing precisely how many tokens have been consumed and what percentage of the window remains available.

The best practices section consolidates these insights into a workflow that developers can immediately adopt. Monitoring the `/context` command regularly should become as habitual as checking a Git status. Splitting tasks into logical granularity prevents scope creep within a single session. The `/clear` command provides a quick reset when the conversation has veered off track, and the deliberate use of fresh sessions after major milestones ensures that each new phase begins with maximum available capacity. Manual compaction, triggered at the developer's discretion rather than the application's, wraps up a segment of work into a compact summary before moving on, preserving the semantic essence while freeing up the window for the next challenge.

Evolving Beyond Single-Call Thinking

The most profound shift this lesson encourages is moving away from the mental model of single-call interactions toward a systems-thinking approach to AI collaboration. Using an agentic coding tool effectively is not about crafting the perfect prompt for a one-shot solution; it is about managing an ongoing computational resource. Just as a developer monitors memory leaks, connection pools, and database connection limits, they must now add context window management to their operational toolkit. The developers who master this systems view will build complex applications with AI assistance cost-effectively, while those who ignore it will encounter increasingly confusing failures as their sessions spiral beyond the window's threshold. CampusX delivers this message through practical demonstration, making clear that the context window is not a mere technical specification but the fundamental currency of agentic development.