Prompt Engineering Is Dead: Why Context Engineering Is the Real Skill in 2026

from dataclasses import dataclass, field
from typing import Any

@dataclass
class ContextWindow:
    """
    The fully assembled context passed to a model.
    Designed to make every layer explicit, separable, and independently testable.
    """
    system_prompt: str
    retrieved_docs: list[dict]
    memory_items: list[dict]
    tool_definitions: list[dict]
    conversation_history: list[dict]
    output_spec: str
    token_budget: int = 16_000

    def assemble(self) -> list[dict]:
        """
        Assembles all layers into a messages array in deliberate order:
        1. System prompt  (instructions first — highest model attention zone)
        2. Memory items   (persistent user context)
        3. Retrieved docs (current query's knowledge, labeled and ordered by relevance)
        4. Tool definitions (capability declaration)
        5. Conversation history (pruned to budget)
        6. Output spec injected into the final user turn
        """
        messages = []

        # System layer: single persistent instruction block
        messages.append({"role": "system", "content": self.system_prompt})

        # Memory layer: surface only episodic items relevant to current session
        if self.memory_items:
            mem_text = self._format_memory(self.memory_items)
            messages.append({
                "role": "system",
                "content": f"Relevant user context from previous sessions:\n{mem_text}"
            })

        # Knowledge layer: retrieved docs with explicit source labels, relevance-ordered
        if self.retrieved_docs:
            docs_text = self._format_retrieved_docs(self.retrieved_docs)
            messages.append({
                "role": "system",
                "content": f"Relevant reference material:\n{docs_text}"
            })

        # Conversation history: budget-aware, pruned oldest first
        history = self._prune_history_to_budget(
            self.conversation_history,
            self._remaining_budget(messages)
        )
        messages.extend(history)

        return messages

    def _format_retrieved_docs(self, docs: list[dict]) -> str:
        # Explicit source labels let the model cite correctly
        # Most relevant doc first (highest cosine score)
        return "\n\n".join(
            f"[{i+1}] Source: {doc['source']}\n{doc['text']}"
            for i, doc in enumerate(docs)
        )

    def _prune_history_to_budget(
        self, history: list[dict], remaining_tokens: int
    ) -> list[dict]:
        """
        Keeps the most recent turns that fit within the remaining token budget.
        Always preserves at minimum the last 2 turns (current exchange context).
        Older turns that summarizable are replaced with a summary block.
        """
        # Simple implementation: keep tail of history that fits
        # Production: run a summarization pass on the evicted head
        kept = []
        running_count = 0
        for turn in reversed(history):
            turn_tokens = len(turn["content"].split()) * 1.3  # rough token estimate
            if running_count + turn_tokens > remaining_tokens:
                break
            kept.insert(0, turn)
            running_count += turn_tokens
        return kept

    def _remaining_budget(self, assembled_so_far: list[dict]) -> int:
        rough_tokens = sum(
            len(m["content"].split()) * 1.3
            for m in assembled_so_far
        )
        return self.token_budget - int(rough_tokens)