Beyond Prompts: An Introduction to "Context Engineering" Dramatically Changing AI Performance

Context Engineering: The Next Evolution of Prompt Design for LLMs

Introduction

The emergence of context engineering marks a pivotal shift in how we interact with large language models. In early LLM applications (think GPT-3 era), much effort went into clever prompt engineering – crafting just the right query to coax a model’s desired output. Today, however, industry leaders argue that prompt tweaks alone are no longer enough for complex AI tasks. Instead, the focus has broadened to engineering the entire context given to the model[1][2]. Shopify CEO Tobi Lütke described “context engineering” as “the art of providing all the context for the task to be plausibly solvable by the LLM”[3]. Similarly, AI researcher Andrej Karpathy has championed the term, noting that in any real-world LLM application, “context engineering is the delicate art and science of filling the context window with just the right information for the next step”[2]. In essence, context engineering extends beyond writing a single prompt – it’s about designing dynamic, context-rich AI interactions that supply the model with everything it needs to perform reliably.

What is Context Engineering?

At its core, context engineering is the practice of systematically optimizing what information you feed an LLM (beyond the user’s immediate question) to achieve the best result[4]. One definition calls it “building dynamic systems to provide the right information and tools in the right format such that the LLM can plausibly accomplish the task.”[5] In other words, context engineering means curating all relevant instructions, data, and hints that go into the model’s context window, not just the user query. This may include background knowledge, retrieved documents, conversation history, user preferences, or tool outputs – anything that gives the model the necessary contextual understanding to solve the problem at hand. Crucially, context engineering has emerged as a more holistic discipline than prompt crafting alone, often described as a “rebranding” or evolution of prompt engineering to encompass the broader information payload an AI needs[6]. It formalizes many techniques that AI developers have been using ad-hoc for years (memory buffers, retrieval augmentation, etc.) into a unified approach for context-aware AI systems.

Illustration of context engineering as an encompassing discipline. It includes traditional prompt engineering and overlaps with retrieval of external knowledge (RAG), memory of prior interactions (state/history), and output formatting. The entire blue circle represents the broader context that an LLM needs, beyond a single prompt.[7][8]

Put simply, context engineering architects the full situation around an AI model. Instead of treating an LLM like an oracle where you toss in one prompt and get an answer, context engineering treats it like a component in a larger system. The AI is given carefully chosen building blocks: a role or system prompt defining its behavior, relevant facts or documents pulled in from outside sources, a record of the conversation so far, definitions of any tools it can use, and instructions on the expected output format. By engineering this surrounding context, we set the model up for success. As researchers recently noted, the performance of LLMs is “fundamentally determined by the contextual information provided during inference,” and context engineering elevates this to a formal discipline beyond simple prompt design[4]. The payoff is that AI responses can be far more accurate, contextual, and useful when the model isn’t working from a blank slate each time but from a rich, relevant context.

Context Engineering vs. Prompt Engineering

How is context engineering different from (and related to) prompt engineering? The key distinction lies in scope and persistence. Prompt engineering usually refers to crafting a single prompt (or a static prompt template with maybe a few examples) to guide the model’s behavior in one shot. In contrast, context engineering looks at the entire interactive session and beyond – it manages what information the model has over multiple turns, where that information comes from, and how it’s maintained or updated.

One commentator put it succinctly: Prompt engineering focuses on “what to say to the model at a moment in time,” whereas Context engineering focuses on “what the model knows when you say it — and why it should care.”[9] Prompt techniques might involve clever wording or a few-shot example to induce the right answer for one query, but context engineering will ensure the model has all the background it needs before you even ask the question. This requires a more systemic, ongoing approach. Prompt engineering often operates within a single input-output cycle and can even be done ad-hoc in a chat interface[10]. Context engineering, by contrast, manages the entire context window across one or many sessions, designing systems that continuously provide the right inputs at the right time (and possibly modify them as the conversation or task evolves)[11]. It might entail maintaining long-term memory, retrieving fresh information when needed, orchestrating tool use, and keeping the dialogue on track over time.

Notably, prompt engineering is now viewed as a subset of context engineering, rather than a competing approach[12][13]. We still need well-written prompts and instructions, but those are just one component within a larger context strategy. As the LangChain team put it, early on developers focused on phrasing prompts cleverly, but as applications grew more complex, “providing complete and structured context to the AI is far more important than any magic wording.”[13] In practice, a robust context-engineered system will include carefully crafted prompts (for example, a persistent system prompt to steer the model’s behavior), yet it does not stop at the prompt. Context engineering = prompt engineering + so much more. It addresses the question: beyond phrasing, what information must we give the model so that it can plausibly solve the task? If the model fails, context engineers first ask: Did we supply the necessary info and guidance? If not, it’s a context failure, not just a model failure[14][15]. This mentality is a shift from trying to “jailbreak” better answers with trick prompts, to building a reliable scaffolding of context around the model.

To visualize the difference, consider a simple example. If you tell ChatGPT “Write a professional email to schedule a meeting,” you’re engaging in prompt engineering – you provide an instruction and maybe some example format, and the model produces an email. But if you’re deploying an AI customer service assistant that needs to handle an ongoing conversation, remember the customer’s name and past issues, look up their order status, and respond in a consistent tone across multiple messages, you’re firmly in the realm of context engineering. The latter requires designing a whole context pipeline: the assistant’s system role, a memory of conversation history, API calls to fetch account data, and so on[16][17]. As one developer wryly observed, the “cheap demo” version of an agent might just call an LLM with the user’s question and get a generic response, whereas the “magical” production version of that agent pulls in calendar info, past interactions, and relevant tools before calling the LLM – resulting in a far more personalized, helpful answer[18][19]. The magic isn’t a smarter model or secret prompt, “it’s in providing the right context for the right task.”[20]

Key Techniques and Components of Context Engineering

Because context engineering is a broad discipline, it spans a variety of techniques for injecting and managing information in an LLM’s context. Researchers break down the field into foundational components like context retrieval, context generation, context processing, and context management[21] – essentially, how you get the information, how you prepare it, and how you maintain it through an AI session. In practical terms, some of the key techniques and components include:

• Retrieval-Augmented Input: Dynamically fetching relevant external data or documents and appending them to the prompt. This is exemplified by Retrieval-Augmented Generation (RAG), which queries a knowledge base or vector database for information related to the user’s query and supplies those facts to the model[22]. By augmenting the context with up-to-date or domain-specific knowledge, the model can answer questions it otherwise wouldn’t know. (For example, finding a policy document snippet when asked a detailed policy question, instead of hoping the model’s training included it.) RAG was one of the first widely-used context engineering techniques to expand an LLM’s knowledge beyond its frozen training data[23].

• Memory and State: Maintaining a record of the conversation and other stateful data so the AI doesn’t lose track of context over time. This can involve short-term memory (including recent dialogue history in the prompt) and long-term memory (retrieving saved facts about the user or past sessions)[24]. For instance, a chat assistant might summarize earlier parts of a conversation once it gets long, and prepend that summary in later prompts to “remember” what was discussed. Or an agent might store user preferences (projects, names, etc.) in a database and retrieve them on each query. Context engineering treats prior interactions as part of the context, ensuring continuity and personalization instead of starting from scratch on every turn[25].

• Tools and APIs Integration: Equipping the LLM with external tools and providing the necessary tool documentation in context. Modern AI agents often have access to tools (like search engines, calculators, databases, or code execution). Context engineering involves feeding the model descriptions of what tools are available and how to use them, and then inserting the results returned by those tools back into the context[26]. For example, if an agent can call a weather_api(city) function, the system prompt might include a short description of this function’s purpose and parameters. Later, when the user asks about today’s weather, the agent’s planning module might invoke the API and then incorporate the API’s response (e.g. the actual weather data) into the prompt it gives the model. In this way, the LLM’s context is augmented with tool outputs and real-time information, enabling it to solve tasks it otherwise couldn’t (like current events, calculations, database queries, etc.).

• Instructions and Role Prompts: Crafting persistent system instructions or role definitions that govern the model’s behavior. Even though context engineering is “beyond prompt engineering,” it still heavily relies on well-designed prompts as building blocks – especially the system prompt (or developer instructions) that set the rules and persona for the AI agent. Part of context engineering is optimizing these instructions and ensuring they persist throughout the interaction[27]. For example, a system message might say: “You are an expert financial advisor. Always speak in a friendly tone and clarify any jargon.” Such instructions might include explicit policies, persona details, or even chain-of-thought guidelines. In context engineering, these prompts are not one-off – they are managed as a constant piece of context that can be updated or refined as needed. The difference from vanilla prompt engineering is that here you might programmatically adjust the system prompt (or add conditional instructions) based on the situation, making it a dynamic contextual controller for the model’s behavior.

• Output Formatting and Examples: Providing the model with structured output requirements and illustrative examples. Context engineering often involves telling the model how to format its answer or giving it a few examples to imitate. This could mean including a JSON schema or template in the prompt when you need a structured output, so the model knows to respond with specific fields. It also includes the classic few-shot examples – but rather than static, these can be dynamically chosen or generated. For instance, before asking a question about a document, you might insert: “(Example Q&A: Q: [some question] A: [well-structured answer])” as a guiding example. By placing good examples and format instructions into context, you reduce ambiguity in the model’s output[28]. This is another area overlapping with prompt engineering, yet under the context engineering umbrella it’s treated as one tool among many (often combined with retrieval and state). The model effectively sees “Here’s how your answer should look” as part of the input.

• Context Optimization (Filtering & Compression): Deciding what NOT to include is just as important as deciding what to include. A practical challenge is the limited context window (even the largest models have token limits), so context engineering must optimize the signal-to-noise ratio. This involves filtering out irrelevant or redundant information and compressing long texts (via summarization or embedding-based truncation) while preserving key details[8]. As one guide noted, “what you are trying to achieve in context engineering is optimizing the information you are providing in the context window… This also means filtering out noisy information”[8]. Techniques here include algorithmically ranking retrieved snippets by relevance, summarizing conversation history when it grows too large, and using formats that convey maximum info in minimal tokens. Even the order of information can matter (for example, putting the most crucial facts near the end of the prompt if the model tends to weight recent tokens more). In short, context engineering treats the context window like a precious budget of information – it must be filled wisely and efficiently[29][30]. “Garbage in, garbage out” applies, so every part of the context should serve a purpose. When done right, this optimization prevents the model from being distracted or overwhelmed by irrelevant text and focuses its attention on what truly matters for the task.

These components often work in concert. For instance, a multi-turn QA agent might retrieve documents (RAG), summarize them (compression), include a few examples of QA format (prompting), maintain the conversation history (memory), and remind the model of its role and tools each time (instructions & tools). A recent survey identified these as foundational building blocks of context engineering, which are then integrated into higher-level architectures like memory-augmented chatbots, tool-using agents, and multi-agent systems[21]. The overarching goal is to fill the LLM’s context window with the “just right” mix of information it needs at each step[31]. Doing this well is “highly non-trivial” and even somewhat of an art (requiring intuition about what the model will do with the context), but it’s increasingly becoming a science grounded in systematic evaluation and best practices[31][32].

Practical Use Cases and Examples

The move from prompt engineering to context engineering is driven by real-world use cases where static prompts fall short. Here are a few scenarios where context engineering shines and is actively being applied:

• Knowledge Base Q&A and Document Analysis: One of the earliest and most widespread applications is enabling LLMs to answer questions using private or up-to-date knowledge. For example, a company might want an AI assistant that can answer questions about internal policies or product documentation. Instead of trying to fine-tune the model on these documents (which is costly and inflexible), developers use retrieval techniques to feed relevant document snippets into the prompt at query time. This retrieval-augmented generation (RAG) approach is pure context engineering: the system breaks documents into chunks, finds which chunks relate to the user’s question, and includes those in the LLM’s context[22][33]. The model, seeing the key passages alongside the question, can then formulate an informed answer. This has proven powerful – RAG systems let LLMs handle questions requiring specific knowledge that wasn’t part of their training data, from legal case research to IT support FAQs. Essentially, context engineering in this use case replaces “Train the model on everything” with “Prompt the model with the right excerpts”, dramatically simplifying how we specialize models for new information.

• Conversational Assistants and Chatbots: Anytime an AI is having a multi-turn conversation (customer support bot, personal assistant, therapy chatbot, etc.), context engineering is at play. The AI needs to remember context from earlier in the conversation – what the user said, what it already answered, and any follow-up points. It may also need to incorporate user-specific data (for example, a support bot pulling the user’s account status and previous tickets). Prompt engineering alone (just writing a clever prompt at each turn) can’t achieve this continuity. Instead, context engineering techniques are used: the conversation history (or a summarized form of it) is appended on each turn, and external lookups are performed as needed. A practical example is a customer service agent that maintains a chat history and also fetches data from a CRM or knowledge base. If a user says “I’m still waiting on my order,” the bot’s system might retrieve that user’s order details and prior support logs, then include: “(Agent, you have the following info: Order #123 shipped 3 days ago, tracking #XYZ...)” in the context before formulating a reply. This allows the model to respond with awareness of specifics, like “I see your order was shipped earlier this week; the tracking number is XYZ.” Without such context engineering, the model would either give a generic apology or hallucinate details. Indeed, ensuring conversation memory and up-to-date info has become a hallmark of context-engineered chatbots[16][34]. The difference is literally night and day – users feel like the AI understands them because it can refer back to what they said before and pull in the correct external knowledge at the right moment.

• Agentic AI Systems and Tool-Using Agents: Beyond simple Q&A, context engineering is fundamental in more advanced AI agents – the kinds that can plan actions, use tools, and perform multi-step tasks (often autonomously). Consider an AI agent that can not only chat with a user but also take actions like browsing the web, executing code, or calling APIs. These agents rely on orchestrating context across steps. For instance, an agent might start with a user request, break it into sub-tasks, use a search tool to gather information, then incorporate those search results into a subsequent prompt to the LLM. Each tool result and each decision becomes part of the evolving context. One example described by developers is an agent that, in the middle of a conversation, realizes it needs the latest stock price – so it calls a stock API, gets the price, and then continues the dialogue including that information[35]. Here the context window becomes a live workspace, updated continuously with new data (tool outputs) and state (what sub-task it’s on). Context engineering provides the glue that holds the agent’s chain of thought together: the system must decide what to keep in the prompt (e.g. intermediate conclusions, recent observations) and what to discard as it moves through tasks. Frameworks for agent building (like LangChain, etc.) heavily emphasize context management for this reason. In multi-agent systems (where multiple LLMs or agent modules talk to each other), context engineering extends to designing protocols for agents to exchange information and memory. Recent experimental protocols like Agent-to-Agent (A2A) messaging or the Model Context Protocol (MCP) are essentially attempts to standardize how context is shared between cooperating AI agents[36][37]. All of this falls under context engineering – going beyond a single prompt to create an ecosystem where AI agents have the knowledge and context they need to act intelligently and consistently over time.

• AI Coding Assistants and IDE Integrations: Another cutting-edge use case is AI coding assistants (e.g. GitHub Copilot, Replit’s Ghostwriter, Cursor, etc.). These tools help developers by suggesting code, finding bugs, or refactoring, and they must deal with the entire context of a software project. This is a complex form of context engineering: the assistant needs to know which files are open, what the project structure is, what the user’s codebase contains, and even the user’s typical coding style. Modern coding copilots use large context windows to stuff in not just the immediate code snippet, but also relevant parts of other files (like definitions of functions or classes being referenced)[38]. They may maintain a history of recent edits or even a short-term “memory” of what the developer has been working on. When you ask “Help me refactor this function,” a good coding assistant will have the context of that function’s content and references to it across the codebase. Perhaps it will have retrieved all usages of that function and loaded them into the prompt so it doesn’t introduce breaking changes. It might also include some high-level project info (framework, coding conventions) and an example of the desired code style. All this context assembly is done behind the scenes, but it dramatically improves the relevance of the AI’s suggestions. Users often notice that these assistants get “smarter” after you’ve been coding with them for a while – that’s because they quietly build up context about your project. In essence, they learn the context, not just the code. This is context engineering at work: blending natural language understanding with structured project data to assist in a deep, context-dependent task. It’s telling that the most advanced code assistants in 2025 leverage both retrieval (indexing your repository) and multi-turn interaction (continuous context) to function – simple prompt engineering would not suffice for something like refactoring an entire codebase.

These examples underscore why context engineering has become so important. Whenever an AI system moves beyond a single Q&A into the realm of situated tasks – holding a conversation, consulting external data, performing actions, adapting to a user – it needs a rich context to do so effectively. Many failures of early AI systems were due to lack of context: the model didn’t recall what was said two turns ago, or it lacked critical facts, or it misunderstood the format. Engineers found that by adding the missing context (e.g. “carry over the user’s last question, include the knowledge base entry on that topic, remind the model of the instructions”), they could fix those failures. As one LangChain blog noted, when an AI agent messes up, often “the underlying model was not passed the appropriate context to make a good output”[14]. This insight – that context failures are frequently the cause of bad AI performance – gave rise to context engineering as a deliberate practice. Now, rather than blaming the model or trying random prompt phrasing tricks, developers ask how they can better engineer the context to prevent errors. Context engineering thus directly addresses issues like hallucinations (by injecting real facts), lack of memory (by caching state), inconsistency (by enforcing formats and roles), and so on. It’s a systematic answer to many of the practical problems observed in deploying LLMs.

Recent Developments and The Future of Context Engineering

Because of its growing importance, context engineering has been the subject of intense discussion, research, and tooling in the past year. In mid-2025 alone, multiple tech blogs, papers, and forums exploded with talk of context engineering being “the next big thing” in AI. For instance, a comprehensive survey published in July 2025 formalized context engineering as a field and provided a taxonomy of techniques and architectures drawn from over 1,400 research papers[4][21]. This survey not only categorized current methods (like RAG, memory systems, tool use, multi-agent contexts) but also highlighted a key challenge: today’s LLMs, even when given advanced context, still struggle to generate very long, coherent outputs compared to how well they can absorb large contexts[39]. In other words, we’ve gotten good at feeding models lots of contextual info (some models can ingest entire books or codebases now), but ensuring the model’s output scales to that complexity is an open problem. Addressing this gap – making outputs as sophisticated as the inputs – is seen as a priority for future research[39]. It’s an interesting reminder that context engineering isn’t a silver bullet by itself; it’s part of a co-evolution between better context-handling and better reasoning/generation capabilities in AI.

On the industry side, nearly every major AI platform has been expanding support for larger and richer contexts. OpenAI notably increased GPT-4’s context window (up to 32k tokens for some versions), and Anthropic went even further by launching Claude with a 100k token context window (capable of reading hundreds of pages in one go). These expanded capacities feed directly into context engineering – enabling use cases like long document analysis and lengthy conversations without resets. However, simply having a bigger window doesn’t eliminate the need for smart context management. In fact, practitioners joke that “if you have a 100k context, you now have 100k opportunities to confuse the model with irrelevant info.” 😉 Studies have shown that blindly throwing everything into a huge prompt can be counterproductive. Anthropic’s own team has published prompting tips for long contexts, emphasizing strategies like extracting only the relevant quotes and giving structured examples to help the model focus[40][41]. As one commentator put it after reviewing Anthropic’s 20,000-token system prompt for Claude 2, “We’ve been thinking about AI wrong. It’s not about clever prompts. It’s about engineering the entire context window.”[42]. In other words, even with massive context lengths, what you put in that context and how you organize it remains critical. A recent article by Drew Breunig illustrated “four surprising ways the context can get out of hand” when using extremely large contexts, such as duplicating irrelevant text, including contradictory information, or exhausting the model’s focus[43]. The takeaway is clear: context quality trumps quantity. Larger windows are great, but without good context engineering, they might just amplify noise or introduce new failure modes (sometimes dubbed “context rot” when irrelevant info accumulates over a long session). This realization is driving even more interest in techniques to automatically refine and manage context, from better retrieval ranking algorithms to AI-driven context summarizers.

Several frameworks and tools have emerged to help developers with context engineering. For example, the LangChain team introduced LangGraph, an agent framework that gives developers fine-grained control over each step of context assembly[44]. Unlike black-box agent APIs, LangGraph lets you explicitly decide which context pieces go into each model call, aligning with the philosophy “own your context window.” Similarly, guidance like Dex Horthy’s “12-Factor Agents” (inspired by the 12-factor app methodology) has been circulated, with rules like Factor 3: Own Your Context Window, meaning you should explicitly design what information goes into your AI agent’s prompts rather than leaving it to chance[45]. We’ve also seen growing communities of AI engineers sharing context engineering tips – for instance, how to structure prompts for reliability, how to combine vector search with keyword search (a technique Anthropic dubbed “contextual retrieval” to avoid missing exact matches)[46][47], or how to use prompt caching to reuse context across calls efficiently[48]. Even the job titles are evolving: some practitioners now facetiously call themselves “Context Engineers” instead of Prompt Engineers, reflecting the broader scope of their work in building AI systems. While the terminology is still shaking out, there’s a strong consensus that mastering context – in all its forms – is becoming one of the most valuable skills in the AI field[49].

Looking ahead, context engineering is poised to play a central role in advanced AI applications. As we develop AI agents that are more autonomous and persistent (think AI assistants that might run continuously, learning and adapting), the way we feed them context will be as important as the model architectures themselves. There’s active research into memory architectures for AI – how an agent can store and retrieve long-term knowledge without overloading its short-term context. Some experimental approaches involve external databases or filesystems acting as the AI’s “memory” (so the model can read/write context rather than hold everything in the prompt)[50][51]. Others explore the model generating its own context (like notes to itself, which it then conditions on). All of these still fall under context engineering, just with the AI helping out in the process. We may also see more standardization: just as web developers have design patterns, AI engineers might adopt standard context patterns (for example, a widely used schema for conversation history + task info + tools section in prompts). And of course, as models improve, they might become more forgiving or savvy about context – e.g. future models might identify irrelevant context on their own or have mechanisms to address inconsistencies. But until then, it’s up to the human builders to curate the model’s context diligently.

In summary, context engineering has quickly moved from an obscure notion to a front-and-center concern in the deployment of LLMs. By going “beyond the prompt” and viewing the problem as one of information architecture, developers are building AI systems that are far more capable, reliable, and tailored to real-world tasks. It bridges the gap between what a raw model can do and what a fully-fledged AI assistant or agent can accomplish when it has the right knowledge and guidance at its fingertips. As one AI newsletter proclaimed, context engineering will “define how intelligent systems behave” and is essential to understand if you want to build the next generation of AI agents[52]. That may be a bold claim, but it reflects the excitement in the field: by mastering context engineering, we gain the tools to unlock the true potential of large language models in practical applications. Going forward, expect to see ever more sophisticated uses of context – and remember, whenever you see an AI impressing people with its usefulness, chances are a context engineer carefully set the stage behind the scenes.

Sources:

• Mei et al., “A Survey of Context Engineering for Large Language Models,” arXiv preprint (July 2025)[4][21]

• LangChain Blog – “The rise of ‘context engineering’,” Harrison Chase (June 2025)[5][13]

• Prompt Engineering Guide – “Context Engineering Guide,” (2025)[27][7]

• Philipp Schmid – “The New Skill in AI is Not Prompting, It’s Context Engineering,” (June 2025)[53][19]

• Vinci Rufus – “Context Engineering – The Evolution Beyond Prompt Engineering,” (July 2025)[54][9]

• DataCamp – “Context Engineering: A Guide with Examples,” (2023)[55][56]

• Simon Willison’s Blog – “Context engineering” (June 2025)[1][2]

• Latent Space Podcast – “RAG is Dead, Context Engineering is King” (Jeff Huber interview), (Aug 2023)[54][11]

• Anthropic – “Introducing Contextual Retrieval,” (Sept 2024)[46][47] (example of improving RAG for better context)

• Anthropic – “Claude 100k Context & Prompting Tips,” (2023)[57] (example of long-context best practices)

• Medium (Luke S.) – “Beyond Prompting: Why Context Engineering is AI’s Next Leap,” (Aug 2025)[40][42] (discussion of Claude’s system prompt and context patterns)

[1] [2] [3] [31] Context engineering

https://simonwillison.net/2025/jun/27/context-engineering/

[4] [21] [39] [2507.13334] A Survey of Context Engineering for Large Language Models

https://arxiv.org/abs/2507.13334

[5] [13] [14] [15] [29] [30] [44] [49] The rise of "context engineering"

https://blog.langchain.com/the-rise-of-context-engineering/

https://www.promptingguide.ai/guides/context-engineering-guide

https://www.vincirufus.com/posts/context-engineering/

https://www.datacamp.com/blog/context-engineering

[18] [19] [20] [24] [25] [26] [52] [53] The New Skill in AI is Not Prompting, It's Context Engineering

https://www.philschmid.de/context-engineering

https://medium.com/@datasciencedisciple/beyond-prompting-why-context-engineering-is-ais-next-leap-ddbe8e08e335

[41] [57] Prompt engineering for Claude's long context window Anthropic

https://www.anthropic.com/news/prompting-long-context

[45] Context Engineering - by Justin Johnson

https://rundatarun.io/p/context-engineering

[46] [47] [48] Contextual Retrieval in AI Systems Anthropic

https://www.anthropic.com/engineering/contextual-retrieval