Context Engineering

The Context Window: The AI's Entire World

An LLM doesn't have memory the way you do. Every time it generates a response, it can only work with what's currently in its context window, a fixed-size buffer measured in tokens. Think of it as a whiteboard. The model can see everything written on the whiteboard right now, but nothing that was erased.

The “Lost in the Middle” Problem

Here's something most people don't know: LLMs don't pay equal attention to everything in the context window. Research has shown they pay significantly more attention to content at the beginning and end of the context, and less attention to content buried in the middle. This is called the lost in the middle phenomenon.

The 6 Types of Context

Context isn't just your prompt. A well-engineered AI system typically assembles context from several distinct sources before the model ever sees your question.

1. System Prompt (Instructions)

The system prompt is the foundational layer of context, set before the conversation begins. It defines the model's role, constraints, personality, output format, and any standing rules. In agent systems like Claude Code, this is where tools, capabilities, and behavioral guidelines live.

You are a senior software engineer at Quick2Bid specializing in Salesforce CPQ integrations.

ROLE:
- Answer questions about CPQ configuration, pricing rules, and quote generation
- Always recommend solutions compatible with Salesforce Spring '24 or later
- Flag anything that could break existing quote templates

OUTPUT FORMAT:
- Lead with the direct answer
- Follow with a code example if relevant
- End with any caveats or gotchas

CONSTRAINTS:
- Never recommend third-party packages without noting they require additional licensing
- If unsure, say so — do not hallucinate Salesforce API names

2. Conversation History (Memory)

Every message you've exchanged in the conversation gets appended to the context. This is why AI can “remember” what you said earlier in a chat: it's literally still in the window. As conversations grow long, older turns get pushed toward the middle (lower attention) or eventually truncated entirely.

3. Retrieved Context (RAG)

RAG (Retrieval Augmented Generation) is the technique of dynamically fetching relevant information from an external knowledge base and injecting it into the context at query time. Instead of trying to put your entire company wiki into the context (impossible), you retrieve only the 3-5 most relevant chunks and inject those.

4. Tool / Function Call Results

When an AI agent uses a tool (searches the web, runs code, reads a file), the result gets appended back into the context. The model then “reads” that result and decides what to do next. This is the core mechanism that makes agents work: the context grows with each action-observation pair.

[System]: You have access to the following tools: read_file, run_bash, search_web

[User]: What does the pricing function in our codebase return?

[Assistant → Tool call]: read_file("src/pricing/calculate.ts")

[Tool result]:
  export function calculatePrice(qty: number, unitPrice: number): number {
    const subtotal = qty * unitPrice;
    const discount = qty > 100 ? 0.15 : qty > 50 ? 0.08 : 0;
    return subtotal * (1 - discount);
  }

[Assistant]: The pricing function applies tiered discounts — 8% for 51-100 units,
15% for 100+ units — and returns the discounted total.

5. Structured Data & Documents

PDFs, spreadsheets, JSON payloads, database query results, API responses: all of these can be injected into context directly. The key skill here is pre-processing: don't dump 40 pages of raw data. Extract, summarize, and structure it so the model can navigate it efficiently.

6. Long-Term Memory

The context window is wiped between sessions. But what if the AI needs to remember things across days, weeks, or projects? That's where long-term memory systems come in. These store information externally and retrieve it back into context when relevant. Claude Code's memory system (the MEMORY.md file) is exactly this: a persistent knowledge store that gets loaded into context at the start of each session.

Context Engineering Patterns That Actually Work

Pattern 1: The Context Sandwich

Use the attention distribution to your advantage. Put the most important instructions at the very beginning (system prompt), put background/reference material in the middle, and re-state the key objective right before the question. The model gets a strong signal at both ends.

[SYSTEM — Beginning, high attention]
You are a CPQ specialist. Your job is to find pricing errors.
Always cite the specific line item when flagging an issue.

[MIDDLE — Reference material, lower attention]
Here is the quote data:
Line 1: Widget A, qty 50, unit price $200, total $9,500...
[...hundreds of lines of data...]

[END — Re-stated objective, high attention]
Review the quote data above. List every line item where the
calculated total does not match qty × unit price × applicable
discount. Format as a table.

Pattern 2: Progressive Context Loading

Don't dump everything at once. Start with high-level context, let the model respond, then load in the detailed context for the next step. This mirrors how a human expert would brief a colleague: overview first, details as needed.

Pattern 3: Context Distillation

Use the AI itself to compress context before passing it to another AI call. Long conversation? Ask the model to summarize the key decisions and facts, then use that summary as the context for the next call instead of the full history. This is how production agent systems handle very long tasks.

// Step 1: Compress the long conversation history
PROMPT: "Summarize this conversation into bullet points covering:
(1) the original goal, (2) decisions made so far,
(3) open questions, (4) constraints discovered.
Be extremely concise — this summary will replace the full history."

// Step 2: Use the summary as context for the next phase
CONTEXT: [summary from step 1]
PROMPT: "Given the above context, continue with the next phase..."

Pattern 4: Explicit Context Framing

Label your context clearly so the model knows what kind of information it's reading and how much to trust it. Unlabeled context blurs together; labeled context gets processed with appropriate weight.

[VERIFIED FACTS — treat as ground truth]
- Product SKU: Q2B-ENT-001
- Current price: $4,200/year
- Contract end date: 2026-09-30

[DRAFT DATA — may contain errors, verify before using]
- Proposed renewal price: $4,800/year
- Discount applied: 10%

[USER'S STATED GOAL]
Generate a renewal quote and flag any pricing inconsistencies.

Context Engineering for Agents (Claude Code)

Agents are where context engineering gets both most powerful and most complex. An agent runs a loop (observe, think, act) and the context window grows with every step. Managing that growth is the difference between an agent that completes complex tasks and one that loses the plot halfway through.

CLAUDE.md: Persistent Agent Context

Claude Code reads a file called CLAUDE.md from your project root at the start of every session and loads it directly into context. This is the most powerful context engineering lever available in Claude Code: persistent, version-controlled briefing document for the agent.

# Project: Quick2Bid CPQ Integration

## What this codebase does
Salesforce LWC components for PandaDoc e-signature integration within the CPQ quote flow.

## Architecture
- /force-app/main/default/lwc/ — all Lightning Web Components
- pandaDocPanel — the main signing panel, loads inside the quote record page
- Always check existing components before creating new ones

## Coding standards
- TypeScript-style JSDoc on all public methods
- Never use @wire without a fallback for null data
- All API callouts go through QuoteApiService — never call Salesforce directly from LWC

## Current context (update as you go)
- Sprint goal: PandaDoc webhook status sync
- Known issue: pandaDocPanel throws when quote has no line items — ticket #204
- Do NOT touch anything in /legacy — it's being deprecated

## How I like to work
- Show me a plan before writing code on anything > 50 lines
- Prefer editing existing files over creating new ones
- Run the linter after every change

The Agent Context Stack

When Claude Code starts working on a task, its context is assembled in layers:

Context Engineering Anti-Patterns

These are the mistakes that silently kill the quality of your AI outputs.

Advanced: Context in Multi-Agent Systems

When multiple AI agents work together (one planning, one coding, one reviewing), context engineering becomes a system design problem. Each agent has its own context window, and you need to deliberately decide what information flows between them and in what form.

// ❌ Bad: passing raw agent output between agents
Agent B context: [10,000 tokens of Agent A's raw reasoning and output]

// ✅ Good: structured handoff document
Agent B context:
HANDOFF FROM: Planning Agent
TASK COMPLETED: Architecture design for auth module
DECISIONS MADE:
  - Use JWT with 15min expiry + refresh tokens
  - Store refresh tokens in httpOnly cookies
  - Rate limit: 5 attempts per IP per 15min
ARTIFACTS PRODUCED:
  - /docs/auth-spec.md (full spec, read if needed)
FILES TO CREATE:
  - src/auth/jwt.ts
  - src/auth/middleware.ts
  - src/auth/routes.ts
CONSTRAINTS:
  - Must be compatible with existing User model schema
  - No new npm packages without approval
YOUR TASK: Implement the above spec.

The Context Engineering Checklist

Run through this before any important AI interaction or before building an AI-powered feature: