Capstok — learn by doing

Why this matters

Not every feature needs heavy context engineering. A one-shot classifier with a fixed prompt barely benefits. But three patterns live or die by it: RAG (you're literally engineering which knowledge enters the window), agents (state and tool results accumulate fast), and long multi-turn assistants (history outgrows the budget). Knowing where the discipline pays off tells you where to invest — and stops you from over-engineering a simple feature.

Demo

A simple decision rule: if the context is fixed and small, prompt engineering is enough. If the context is dynamic (varies per request), large (approaches the budget), or growing (accumulates over a session), you need context engineering. The table-as-code below encodes that judgment.

Try it yourself

Score three features you've built or want to build. Be honest about whether context grows over a session.
Find a 'minimal' feature you over-engineered (added retrieval it didn't need) and a 'heavy' one you under-invested in.
Change one input (e.g. window from 200K to 8K) and watch a 'light' feature flip to 'heavy' — smaller models raise the stakes.
Write down the single feature in your roadmap that scores 3. That's where this course pays back fastest.

Prompt your AI

Use these three in order. Each builds on the one before.

1. Basics & terminology

Which kinds of LLM features benefit most from context engineering, and which barely need it? Give me a quick rule of thumb.

2. Why it works (the mechanism)

Explain why RAG, agents, and long multi-turn assistants are the three patterns where context engineering is decisive, in terms of how their context behaves over time.

3. Advanced — application & what's next

I have a roadmap of 6 AI features and limited time. Give me a framework to rank them by how much context engineering would improve them, so I invest effort where it pays off.

References

Chat about this lesson

def needs_context_engineering(feature):
    dynamic = feature["context_varies_per_request"]
    large   = feature["context_tokens"] > 0.5 * feature["window"]
    growing = feature["accumulates_over_session"]
    score = sum([dynamic, large, growing])
    return ("heavy" if score >= 2 else "light" if score == 1 else "minimal"), score

print(needs_context_engineering(
    {"context_varies_per_request": True, "context_tokens": 120_000,
     "window": 200_000, "accumulates_over_session": True}))   # ('heavy', 3) — RAG agent
print(needs_context_engineering(
    {"context_varies_per_request": False, "context_tokens": 500,
     "window": 200_000, "accumulates_over_session": False}))  # ('minimal', 0) — classifier

Run: python3 main.py

Where context engineering pays off most