Practice context engineering vocabulary: context windows, context-aware prompting, compression, curation, and retrieval strategies.
0 / 23 completed
1 / 23
A developer says 'Context is what you put in the prompt window.' In modern LLM usage, what does the 'context window' contain?
The context window is the total input an LLM receives — it can include a system prompt, prior conversation turns, retrieved documents (RAG), tool call results, and the current user message. Everything the model 'sees' at inference time.
2 / 23
Your team discusses 'context curation vs. retrieval.' What does context curation mean?
Context curation is the deliberate selection of what information to include in the prompt — choosing the most relevant, useful, and non-redundant content. Retrieval is one source; curation decides what retrieved content actually goes in.
3 / 23
An engineer says 'We compress context to fit the window.' What is context compression?
Context compression involves summarizing long histories, removing redundant information, or using specialized compression models to reduce the number of tokens while retaining the information the model needs to perform the task.
4 / 23
A colleague says 'We need context-aware prompting for this feature.' What does context-aware prompting mean?
Context-aware prompting means the prompt is dynamically constructed based on available context — the user's history, their current task, prior outputs, or retrieved knowledge — rather than being a static template.
5 / 23
Your design doc says 'The context includes the user's history.' Why is including conversation history important for multi-turn interactions?
Including conversation history ensures the model maintains coherence across turns — it can refer back to what was discussed, avoid repeating questions, and build on earlier context rather than treating each turn as a fresh start.
6 / 23
Reviewer: 'The API response is returning a lot of context. We need to prune it down.' What does the reviewer *most likely* mean in this scenario?
The reviewer's comment highlights an inefficiency – overly large context. In this case, 'pruning' refers to removing superfluous information from the API response. The goal is to reduce bandwidth usage and improve performance by only sending *relevant* contextual data to the user or application. Options A, C, and D misinterpret 'pruning' as a debugging action or an API formatting issue; the core concept here is filtering for relevance.
7 / 23
Senior Dev: "I'm seeing some performance issues with our chatbot. It's taking a long time to process requests and the logs show it's spending a lot of time fetching context from the knowledge base. We need to investigate why."
This scenario highlights a common problem when working with large language models. The 'context window' has a finite size; if the system retrieves an excessive amount of context—perhaps including irrelevant or verbose information—it will significantly slow down processing times and potentially lead to errors. This option directly addresses the performance issue by identifying the root cause: retrieving too much data. Options A and C describe alternative problems, while option B suggests a logical but incorrect diagnosis regarding semantic filtering.
8 / 23
Sarah: 'Okay team, I've been looking at the new LLM integration and it's *amazing*! We're feeding it all the relevant user data – their previous queries, the current task they're working on, even the product documentation they've recently accessed. It seems to be generating much more accurate responses.'
Mark: 'That sounds like a lot of context. Are we sure that's necessary? Shouldn't we just give it the core prompt and let it figure things out?'
The key here isn't just about *having* context, but its *impact*. While providing extensive contextual data can initially seem overwhelming, it allows the LLM to generate more relevant and accurate responses by understanding the user's intent within a broader framework. The correct answer highlights that this richer context dramatically improves response quality, addressing Mark's concern about potential overhead – the LLM can leverage the provided information to optimize its processing.
9 / 23
Reviewer: 'The API response is returning a lot of context. We need to prune it down.' What does the reviewer *most likely* mean in this scenario?
The reviewer's comment highlights an inefficiency – overly large context. In this case, 'pruning' refers to removing superfluous information from the API response. The goal is to reduce bandwidth usage and improve performance by only sending *relevant* contextual data to the user or application. Options A, C, and D misinterpret 'pruning' as a debugging action or an API formatting issue; the core concept here is filtering for relevance.
10 / 23
Senior Dev: "I'm seeing some performance issues with our chatbot. It's taking a long time to process requests and the logs show it's spending a lot of time fetching context from the knowledge base. We need to investigate why."
This scenario highlights a common problem when working with large language models. The 'context window' has a finite size; if the system retrieves an excessive amount of context—perhaps including irrelevant or verbose information—it will significantly slow down processing times and potentially lead to errors. This option directly addresses the performance issue by identifying the root cause: retrieving too much data. Options A and C describe alternative problems, while option B suggests a logical but incorrect diagnosis regarding semantic filtering.
11 / 23
Sarah: 'Okay team, I've been looking at the new LLM integration and it's *amazing*! We're feeding it all the relevant user data – their previous queries, the current task they're working on, even the product documentation they've recently accessed. It seems to be generating much more accurate responses.'
Mark: 'That sounds like a lot of context. Are we sure that's necessary? Shouldn't we just give it the core prompt and let it figure things out?'
The key here isn't just about *having* context, but its *impact*. While providing extensive contextual data can initially seem overwhelming, it allows the LLM to generate more relevant and accurate responses by understanding the user's intent within a broader framework. The correct answer highlights that this richer context dramatically improves response quality, addressing Mark's concern about potential overhead – the LLM can leverage the provided information to optimize its processing.
12 / 23
Reviewer: 'The API response is returning a lot of context. We need to prune it down.' What does the reviewer *most likely* mean in this scenario?
The reviewer's comment highlights an inefficiency – overly large context. In this case, 'pruning' refers to removing superfluous information from the API response. The goal is to reduce bandwidth usage and improve performance by only sending *relevant* contextual data to the user or application. Options A, C, and D misinterpret 'pruning' as a debugging action or an API formatting issue; the core concept here is filtering for relevance.
13 / 23
Senior Dev: "I'm seeing some performance issues with our chatbot. It's taking a long time to process requests and the logs show it's spending a lot of time fetching context from the knowledge base. We need to investigate why."
This scenario highlights a common problem when working with large language models. The 'context window' has a finite size; if the system retrieves an excessive amount of context—perhaps including irrelevant or verbose information—it will significantly slow down processing times and potentially lead to errors. This option directly addresses the performance issue by identifying the root cause: retrieving too much data. Options A and C describe alternative problems, while option B suggests a logical but incorrect diagnosis regarding semantic filtering.
14 / 23
Sarah: 'Okay team, I've been looking at the new LLM integration and it's *amazing*! We're feeding it all the relevant user data – their previous queries, the current task they're working on, even the product documentation they've recently accessed. It seems to be generating much more accurate responses.'
Mark: 'That sounds like a lot of context. Are we sure that's necessary? Shouldn't we just give it the core prompt and let it figure things out?'
The key here isn't just about *having* context, but its *impact*. While providing extensive contextual data can initially seem overwhelming, it allows the LLM to generate more relevant and accurate responses by understanding the user's intent within a broader framework. The correct answer highlights that this richer context dramatically improves response quality, addressing Mark's concern about potential overhead – the LLM can leverage the provided information to optimize its processing.
15 / 23
Reviewer: 'The API response is returning a lot of context. We need to prune it down.' What does the reviewer *most likely* mean in this scenario?
The reviewer's comment highlights an inefficiency – overly large context. In this case, 'pruning' refers to removing superfluous information from the API response. The goal is to reduce bandwidth usage and improve performance by only sending *relevant* contextual data to the user or application. Options A, C, and D misinterpret 'pruning' as a debugging action or an API formatting issue; the core concept here is filtering for relevance.
16 / 23
Senior Dev: "I'm seeing some performance issues with our chatbot. It's taking a long time to process requests and the logs show it's spending a lot of time fetching context from the knowledge base. We need to investigate why."
This scenario highlights a common problem when working with large language models. The 'context window' has a finite size; if the system retrieves an excessive amount of context—perhaps including irrelevant or verbose information—it will significantly slow down processing times and potentially lead to errors. This option directly addresses the performance issue by identifying the root cause: retrieving too much data. Options A and C describe alternative problems, while option B suggests a logical but incorrect diagnosis regarding semantic filtering.
17 / 23
Sarah: 'Okay team, I've been looking at the new LLM integration and it's *amazing*! We're feeding it all the relevant user data – their previous queries, the current task they're working on, even the product documentation they've recently accessed. It seems to be generating much more accurate responses.'
Mark: 'That sounds like a lot of context. Are we sure that's necessary? Shouldn't we just give it the core prompt and let it figure things out?'
The key here isn't just about *having* context, but its *impact*. While providing extensive contextual data can initially seem overwhelming, it allows the LLM to generate more relevant and accurate responses by understanding the user's intent within a broader framework. The correct answer highlights that this richer context dramatically improves response quality, addressing Mark's concern about potential overhead – the LLM can leverage the provided information to optimize its processing.
18 / 23
During a standup meeting, Alex says: 'I'm working on integrating the new LLM. I'm feeding it all the relevant user data – their previous queries, the current task they're working on, even the product documentation.' What is Alex primarily referring to when discussing 'context' in this scenario?
The information needed to provide a more accurate and personalized response to the user.
Alex is using 'context' to describe the information needed for the LLM to generate a relevant response. This includes details about the user's current task and the available documentation – all factors that shape the context of the interaction. Options A, B, and C are incorrect because they represent different types of data or system components rather than the informational background required by the LLM.
19 / 23
You're drafting a PR description for adding context management to a new feature. Which of the following best summarizes the core concept being implemented?
// New code: ContextManager class handles retrieving and updating user context
The central idea of context engineering is adapting the system's behavior based on the available 'context.' This means tailoring responses and actions to the specific situation – in this case, the user's current state. Options A, B, and C describe different technical implementations (error handling, configuration, database management) but don't capture the fundamental principle of dynamic adaptation.
20 / 23
A colleague sends you this Slack message: 'I'm seeing some weird behavior with the chatbot. It keeps suggesting irrelevant product recommendations based on the user's recent search history. We need to ensure we're providing it with enough context!' What is the primary issue being highlighted in this Slack conversation?
!help
The message indicates that the chatbot's behavior is poor because it lacks sufficient context. 'Context' here refers to relevant user data (search history) used to generate suggestions. Options A, B, and C describe alternative causes of the problem—training data, system instability, or network issues — which are not directly addressed in the Slack message.
21 / 23
Reviewer: 'The API response is returning a lot of context. We need to prune it down.' What does the reviewer most likely mean in this scenario?
Option A: The API response should be returned immediately, regardless of its size.
Option B: The API response should only contain the absolute minimum amount of contextual data needed for the current request to optimize performance.
Option C: The API response format is incorrect and needs a complete redesign.
Option D: The team should focus on increasing the overall bandwidth of the API.
This question tests understanding of 'pruning' in the context of API responses. 'Pruning' refers to reducing the amount of data returned – specifically, removing unnecessary contextual information that isn't directly relevant to the immediate request. This is a common optimization technique to improve response times and reduce bandwidth usage. Option A is incorrect as it ignores performance considerations; option C addresses a different issue (format), and option D is unrelated.
22 / 23
Sarah: 'Okay team, I've been looking at the new LLM integration and it's *amazing*! We're feeding it all the relevant user data – their previous queries, the current task they're working on, even the product documentation… What is Sarah primarily focusing on when describing this process?
Option A: The security protocols surrounding the storage of user data.
Option B: The efficiency of the LLM's core algorithms.
Option C: Providing the LLM with a comprehensive set of contextual data to improve its responses and decision-making capabilities.
Option D: Optimizing the user interface for interacting with the LLM.
Sarah's statement highlights the importance of *context* in this scenario. She's emphasizing the inclusion of diverse data points – past queries, current tasks, product documentation – to enrich the information provided to the LLM. This directly relates to 'Context Engineering' - feeding the system with all necessary inputs.
23 / 23
During a standup meeting, Alex says: 'I'm working on integrating the new LLM. I'm feeding it all the relevant user data – their previous queries, the current task they're working on, even the product documentation.' What is Alex communicating about his primary task?
Option A: He is building a basic API endpoint for accessing the LLM.
Option B: He is configuring the LLM's hardware infrastructure.
Option C: He is populating the LLM with contextual information to enhance its ability to respond effectively.
Option D: He is writing unit tests to ensure the LLM's functionality.
Alex's statement reveals he's focusing on providing the LLM with relevant *context*—the data that informs its responses. This directly aligns with context engineering – preparing and delivering the right information to the system. Options A-D represent different stages of development not the core activity here.
What will I practice in "Context Engineering Vocabulary"?
This is an AI Prompting exercise set. It walks through 23 scenario-based multiple-choice questions built around real usage of AI Prompting terminology that IT professionals encounter on the job.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free to complete with no account, sign-up, or paywall.
How many questions are in this exercise?
This set contains 23 questions. Each one shows immediate feedback and a detailed explanation after you answer, so you learn the correct usage right away rather than waiting for a final score.
Do I need prior experience to complete this exercise?
No prior experience is required. Each question includes a full explanation covering the reasoning behind the correct answer, so the exercise itself teaches the AI Prompting vocabulary as you go.
Can I retry the exercise if I get questions wrong?
Yes — use the "Try again" button on the results screen to reset your answers and go through all the questions again. There is no limit on attempts.
Is my progress saved?
Your answers and score for the current session are tracked in the browser as you go. No account or login is needed, and there is nothing to install.
What if I don't understand a term used in a question?
Read the explanation shown after you answer each question — it breaks down the correct term in plain English with a real-world example. You can also check the site Glossary for quick definitions.
How is this different from reading a blog article on the topic?
Exercises like this one are interactive drills that test and reinforce specific vocabulary through multiple-choice questions, while blog articles explain concepts in prose. Practising here after reading builds active recall, not just passive recognition.
Where can I find more AI Prompting exercises?
See the AI Prompting exercises hub for the full set of related pages, or browse all exercise categories from the main Exercises index.
Can I use this exercise to prepare for a technical interview?
Yes — AI Prompting vocabulary comes up often in technical discussions and interviews. Pair this exercise with our dedicated Interview Preparation section for role-specific practice.