Prompt engineering – How to optimize context in code generation prompts?

Prompt engineering is the practice of carefully crafting the initial input to a large language model in order to produce a specific and desired output. This is an important consideration when using large language models, as the quality and relevance of the model’s output are heavily influenced by the input it is given. By carefully engineering the relevant code context, it is possible to improve the accuracy and relevance of the model’s responses and to guide it toward producing output that is more useful and valuable. One way to optimize the prompt’s token limit is to make use of classical optimization algorithms such as knapsack.

The Knapsack Problem

The 0/1 knapsack problem is a well-known problem in computer science that involves maximizing the value of items that can be placed in a knapsack with limited capacity. In the context of code generation, the greedy 0/1 knapsack algorithm can be used to optimize the selection of code context tokens to include in a prompt, given a maximum limit on the number of tokens that can be used. code context can be, for example, calling and called functions or classes, imports, corresponding test functions, etc.

The greedy 0/1 knapsack algorithm is a simple and efficient approach to solving the 0/1 knapsack problem. It works by iteratively selecting the most valuable items that can be added to the knapsack without exceeding its capacity. The algorithm continues until either the knapsack is full or there are no more items that can be added.

Code Generation

In the context of code generation, the items in the knapsack would correspond to the tokens that can be used in the prompt, and the value of each item would be determined by its contribution to the overall quality of the generated code. For example, a code context type that frequently appears in high-quality code samples (for example – a called function), may be given a higher value than a token that is less commonly used in such samples.

Let’s take a look at the following Python code example – For the sake of simplicity we will limit our prompt to 20 code lines (instead of tokens), however, the example includes 29 lines. An optimization process such as the one described above can decide that the 13 lines of third_function code (which inflates the prompt) can be pruned to its comment and header, i.e. 3 lines, which puts the prompt’s length within its limitation.

To apply the greedy 0/1 knapsack algorithm to this problem, we first need to determine the maximum number of tokens that can be included in the prompt. This would typically be based on factors such as the length of the prompt, the expected size of the response, and the length of the prompt template (i.e., the query and other available information).


The vanilla version of the 0/1 knapsack, doesn’t take into account constraints between the items, and the items aren’t fractional (dividable). Code context items, however, can usually be divided into several sub-component combinations such as code component signatures, comments, body, etc. Selected sub-component mutually exclude all other sub-components. For example, if we have chosen to include a function including its signature, comments, and body, we shouldn’t choose other parts of this function. Once we have determined the maximum number of tokens, we can iterate through the available tokens and select the ones with the highest value that can be added to the prompt without exceeding the token limit. This process continues until either the token limit is reached or there are no more tokens that can be added.

One potential limitation of the greedy 0/1 knapsack algorithm is that it may not always produce the optimal solution to the 0/1 knapsack problem. This is because the algorithm only considers the most valuable items at each step and does not take into account the overall value of the items that have already been selected. As a result, it may sometimes be possible to achieve a higher overall value by selecting a different set of items.

Despite this limitation, the greedy 0/1 knapsack algorithm is still a useful tool for optimizing the selection of prompt tokens for code generation. Its simplicity and efficiency make it well-suited to this problem, and by carefully selecting the values for the tokens it is possible to achieve high-quality code generation using the greedy 0/1 knapsack algorithm.

More from our blog