Conversational Development With Claude Code — Part 4: Context, Subagents, and the Discipline of Thinking
Source: Dev.to
TL;DR — Claude Code is not powered by perfect prompts, but by well‑designed context. To work with intention and precision, you must understand five pillars: the context window, subagents, the Model Context Protocol (MCP), the CLI, and context engineering. Together, they explain how Claude thinks, remembers, and collaborates — and how you can build reliable systems without micromanaging an LLM.
Why Context Beats Prompts
Most failures with AI tooling do not come from weak models, but from poorly designed context. Developers chase the mythical “perfect prompt” when the real leverage lies elsewhere: in what the system can see, remember, and prioritize.
Claude Code is designed for engineers who think in systems, not incantations. It rewards structure, references, and intent — not verbosity.
The Context Window: Claude’s Working Memory
The context window is Claude Code’s working memory. It contains everything the model can reason about at once: source code, conversations, command outputs, and intermediate results.
- Default size: ~200,000 tokens
- Optional size: 1 M‑token window for larger projects
Key properties
- Holds code, conversation, and execution results together
- Prioritizes relevance over chronology
- Automatically evicts low‑value information when space is constrained
This is not long‑term memory; it is active cognition. When the window fills, Claude compresses. Your job is to ensure what remains is what matters.
Memory Hygiene: References Over Copy‑Paste
The fastest way to poison context is to paste massive blocks of code. Instead, Claude Code is designed around references:
@path/to/file- Loads only what is needed
- Re‑anchors decisions explicitly when starting new sessions
If Claude begins to “forget,” the fix is not repetition — it is reset and refocus: open a new session, re‑reference the critical files, restate architectural constraints, and continue. Clean context beats persistent noise.
Subagents: A Modular Team, Not a Monolith
Subagents turn Claude Code from a tool into a team. Each subagent operates with:
- Its own isolated context
- Specialized instructions
- Dedicated tools
Typical subagents
- Architecture agent — analyzes system structure and constraints
- Backend agent — designs and implements APIs
- Frontend agent — builds UI components and state flows
- QA agent — validates behavior, tests, and edge cases
The main session becomes a coordinator, mirroring real engineering teams: specialization without fragmentation.
When to Invoke Each Subagent
- Backend agent → endpoints, schemas, integrations
- Frontend agent → components, UX flows, state management
- QA agent → tests, regressions, validation
- Architecture agent → refactors, boundaries, long‑term decisions
If the main conversation feels crowded, you waited too long to delegate.
MCP and the CLI: The Nervous System
Claude Code lives in the terminal. MCP (Model Context Protocol) extends its reach. Together they form a tight loop:
- MCP connects Claude to real tools
- The CLI executes commands and returns truth
- Claude interprets, not guesses
With MCP, Claude can:
- Query databases
- Run automated tests (e.g., Playwright)
- Inspect GitHub issues and pull requests
- Interact with tools like Figma or Zapier
Once configured, these integrations feel native — not bolted on.
Using the CLI Without Breaking Flow
The CLI is the execution layer, not a side channel. Best practices
-
Prefix commands with
!to execute, e.g.:!git status -
Let Claude read and interpret the outputs
Roles
- Terminal → execution
- Editor → writing
- Browser → validation
Claude reasons after commands run. That distinction matters.
Context Engineering: Designing Shared Thought
Context engineering is not prompt engineering; it is the discipline of shaping a shared thinking space.
Practical steps
- Define purpose before action
- State constraints explicitly
- Reference files instead of pasting code
- Specify quality bars and anti‑patterns
- Aggressively remove irrelevant information
Avoid vague instructions—ambiguity creates noise. Precision creates leverage.
Final Thoughts
Claude Code does not replace judgment — it amplifies it. When you treat context as an architectural artifact, not a side effect, the system becomes predictable, composable, and trustworthy. Stop chasing prompts; start designing cognition.