25,000 words long article details prompt word engineering-2025 Google white paper: How to optimize AI models through prompt word engineering

Large language models (LLMs) are increasingly being used, and writing high-quality prompts is crucial to fully utilize the power of LLMs. The commands that ordinary users enter in the large model chat interface are also prompts, but engineered prompts are more precise and complex. In particular, large model application developers need to perform more configurations when calling large model APIs, and design and optimize prompts, which requires mastering prompt engineering technology.

The "Prompt Engineering" white paper jointly launched by Google team members uses the Gemini large model as an example to provide us with valuable guidance on how to optimize prompt words and improve LLM output effects.

By Lee Boonstra, Google

Translator: Financial IT Things (translated and proofread based on the big model)

Table of contents

text

You don’t need to be a data scientist or machine learning engineer — everyone can write prompt words.

Introduction

When thinking about the inputs and outputs of a large language model, a text prompt (sometimes along with other modalities like image prompts) is the input that the model uses to predict a specific output. You don’t need to be a data scientist or machine learning engineer — everyone can write prompts. However, designing the most effective prompts can be complex. Many aspects of prompts affect their effectiveness: the model used, the data the model is trained on, the model configuration, wording choices, style and tone, structure, and context all matter. Therefore, prompt engineering is an iterative process. Inadequate prompts can lead to vague, inaccurate responses and prevent the model from providing meaningful output.

When you talk to the Gemini chatbot, you are essentially writing prompts, but this white paper focuses on writing prompts directly to the Gemini model in Vertex AI or through the API because writing prompts directly to the big model gives you access to configurations such as temperature.

This white paper discusses cue engineering in detail. We’ll explore various cue techniques to get you started, and share tips and best practices for becoming a cue expert. We’ll also discuss some of the challenges you may face when writing cue words.

Prompt word project

Remember how the Big Language Model works; it is a prediction engine. The model takes sequential text as input and then predicts what the next token should be based on its training data. The Big Language Model predicts the next token by repeating this process over and over again, adding the previously predicted token to the end of the sequential text . The prediction of the next token is based on the relationship between previous tokens and what the Big Language Model has seen during training.

When you write a prompt, you are trying to set up the big language model to predict the correct sequence of tokens . Prompt engineering is the process of designing high-quality prompts that guide the big language model to produce accurate output. This process involves tuning to find the best prompt, optimizing the prompt length, and evaluating how the writing style and structure of the prompt relate to the task. In the context of natural language processing and big language models, a prompt is the input provided to the model to generate a response or prediction.

These hints can be used to achieve a variety of understanding and generation tasks such as text summarization, information extraction, question answering, text classification, language or code translation, code generation, and code documentation or reasoning.

Feel free to refer to Google ’s prompt word guidelines2,3 which contain examples of simple and effective prompt words.

When engineering cue words, you’ll start by choosing a model. Whether you use the Gemini language model from Vertex AI , GPT , Claude , or an open source model like Gemma or LLaMA , cue words may need to be optimized for your specific model.

In addition to the prompt words, you also need to adjust various configurations of the large language model.

Large language model output configuration

After choosing a model, you need to determine the model configuration. Most large language models offer a variety of configuration options that control the model output. Effective cue word engineering requires optimizing these configurations for your task.

Output length

An important configuration setting is the number of tokens generated in the response . Generating more tokens requires more computation for large language models, resulting in higher energy consumption, potentially slower response times, and higher costs.

Reducing the output length of a large language model will not make the model more stylized or concise in the output, it will just cause the large language model to stop predicting more tokens when it reaches the limit . If your needs require a shorter output length, you may also want to design your prompts to accommodate.

Output length limits are particularly important for certain large language model prompt techniques (such as ReAct ), where the large language model continues to emit useless tokens after the response you want .

Note that generating more tokens requires more computation on a large language model, resulting in higher energy consumption and potentially slower response times, thus increasing costs.

Sampling control

The big language model does not formally predict a single token . Instead, the big language model predicts the probability of what the next token might be, assigning a probability to each token in the big language model vocabulary . These token probabilities are then sampled to determine the next generated token . Temperature, Top-K , and Top-P are the most common configuration settings that determine how the predicted token probabilities are processed to select a single output token .

temperature

The temperature controls the degree of randomness in token selection. Lower temperatures are good for prompts that expect a more deterministic response, while higher temperatures may lead to more diverse or unexpected results. A temperature of 0 (greedy decoding) is deterministic: the token with the highest probability is always chosen (although note that if two tokens have the same highest predicted probability, depending on how tie handling is implemented, you may not always get the same output with a temperature of 0 ).

Temperatures closer to the maximum tend to create more random outputs. As the temperature gets higher, all tokens become equally likely to be the next predicted token .

Gemini temperature control can be understood similarly to the softmax function used in machine learning . Low temperature settings reflect a low softmax temperature ( T ), emphasizing a single, preferred temperature with a high degree of certainty. Higher Gemini temperature settings are similar to high softmax temperatures, making the range of acceptable temperatures around the selected setting wider. This increased uncertainty accommodates scenarios where strict, precise temperatures are not needed, such as when experimenting with creative output.

Top-K and Top-P

Top-K and Top-P (also known as kernel sampling) are two sampling settings used in large language models to restrict the predicted next token to the token with the highest predicted probability . Similar to temperature, these sampling settings control the randomness and diversity of the generated text.

Top-K sampling selects the top K most likely tokens from the model's predicted distribution . The higher the Top-K , the more creative and diverse the model's output is; the lower the Top-K , the more restricted and factual the model's output is. A Top-K of 1 is equivalent to greedy decoding.

Top-P sampling selects the top tokens whose cumulative probability does not exceed a certain value ( P ) . The value of P ranges from 0 (greedy decoding) to 1 (all tokens in the vocabulary of a large language model ).

The best way to choose between Top-K and Top-P is to try both approaches (or both together) to see which produces the results you are looking for.

Comprehensive Application

The choice between Top-K , Top-P , temperature, and the number of tokens to generate depends on the specific application and desired results, and these settings all affect each other. It is also important to make sure you understand how the selected model combines different sampling settings together.

If Temperature, Top-K , and Top-P are all available (such as in Vertex Studio ), tokens that meet the Top-K and Top-P criteria are candidates for the next prediction token , and then temperature is applied to the tokens that pass the Top-K and Top-P criteria for sampling. If only Top-K or Top-P is available, the behavior is the same, but only one Top-K or P setting is used.

If the temperature is not available, a random selection of tokens that satisfy the Top-K and / or Top-P criteria is performed to generate a single next prediction token .

At extreme settings of a sampling configuration value, the sampling setting either cancels out other configuration settings or becomes insignificant.

( 1 ) If the temperature is set to 0 , Top-K and Top-P become irrelevant - the most likely token becomes the next predicted token . If the temperature is set extremely high (higher than 1 - usually above 10 ), the temperature becomes irrelevant, and tokens that pass the Top-K and / or Top-P criteria are randomly sampled to select the next predicted token .

( 2 ) If Top-K is set to 1 , temperature and Top-P become irrelevant. Only one token passes the Top-K criterion, and that token is the next predicted token . If Top-K is set extremely high, such as the size of a large language model vocabulary, any token with a non-zero probability of becoming the next token will satisfy the Top-K criterion, and no token will be filtered out.

( 3 ) If Top-P is set to 0 (or a very small value), most large language model sampling implementations will only consider the most likely tokens to satisfy the Top-P criterion, making temperature and Top-K irrelevant. If Top-P is set to 1 , any token with a non-zero probability of becoming the next token will satisfy the Top-P criterion, and no tokens will be filtered out.

As a general starting point, a Temperature of 0.2 , a Top-P of 0.95 , and a Top-K of 30 will give you relatively coherent results that can be creative but not overly so. If you want particularly creative results, try starting with a Temperature of 0.9 , a Top-P of 0.99 , and a Top-K of 40. If you want less creative results, try starting with a Temperature of 0.1 , a Top-P of 0.9 , and a Top-K of 20. Finally, if your task always has a single correct answer (such as answering a math problem), start with a Temperature of 0 .

Note: The higher the degrees of freedom (higher temperature, Top-K , Top-P , and output tokens ), the less relevant the text generated by the large language model may be.

Warning: Have you ever seen a response end with a lot of filler words? Also known as the " repeating loop error , " this is a common problem in large language models where the model gets stuck in a loop, repeatedly generating the same (filler) words, phrases, or sentence structures, often exacerbated by inappropriate temperature and Top-K/Top-P settings. This can happen at both low and high temperature settings, although for different reasons. At low temperatures, the model becomes too deterministic, strictly following the highest probability path, which can lead to loops if that path revisits previously generated text. Conversely, at high temperatures, the model's output becomes too random, increasing the probability that a randomly selected word or phrase will accidentally lead back to a previous state, creating loops due to the large number of available options. In both cases, the model's sampling process " gets stuck , " resulting in monotonous and useless output until the output window fills up. Fixing this problem usually requires careful tuning of the temperature and Top-K/Top-P values ​​to find the best balance between determinism and randomness.

Tips for using prompt words

Big language models are tuned to follow instructions and are trained on large amounts of data, so they can understand the prompt words and generate answers. But big language models are not perfect; the clearer your prompt word text is, the better it is for the big language model to predict the next likely text. In addition, specific techniques that take advantage of how big language models are trained and work will help you get relevant results from big language models.

Now that we understand what cue word engineering is and what it entails, let’s dive into some of the most important examples of cue word techniques.

General prompt word / zero sample

A zero-shot prompt is the simplest type of prompt. It provides only a description of the task and some text for the larger language model to start with. This input can be anything: a question, the beginning of a story, or an instruction. The name zero-shot stands for “ no example ” .

Let’s use Vertex AI6 in Vertex AI Studio (for Language) , which provides a playground for testing cue words. In Table 1 , you’ll see an example of a zero-shot cue word for classifying movie reviews.

A good way to record your cue words is in a table format like the one below. Your cue words may go through many iterations before they make it into the code base, so it’s important to track your cue word engineering efforts in a disciplined, structured way. For more information about this table format, the importance of tracking cue word engineering efforts, and the cue word development process, see the “ Best Practices ” section later in this chapter ( “ Recording Various Cue Word Attempts ” ).

The model temperature should be set to a low number, and since no creativity is needed, we use the default Top-K and Top-P values ​​from gemini-pro , which effectively disables both settings (see " Large Language Model Output Configuration " above ). Note the generated output. The words "disturbing"  and "masterpiece"  should make the predictions slightly more complicated, since both words are used in the same sentence.

Table 1.  Examples of zero-shot cue words

When zero-shot doesn’t work, you can provide a demonstration or example in the prompt, which leads to “ one -shot ” and “ few-shot ” prompts .

One-shot vs. few-shot

When creating prompts for your AI model, it is very helpful to provide examples. These examples can help the model understand what you are asking of it. Examples are particularly useful when you want to guide the model to a specific output structure or pattern.

A single-shot prompt provides one example, hence the name single-shot. The idea is that the model has one example that it can imitate to best perform the task.

Few-shot cues provide multiple examples to the model. This approach shows the model a pattern to follow. The idea is similar to single-shot, but multiple examples of the desired pattern increase the chances of the model following the pattern.

The number of examples you need for a few-shot prompt depends on several factors, including the complexity of the task, the quality of the examples, and the capabilities of the generative AI ( gen AI ) model you are using. As a general rule of thumb, you should use at least three to five examples for a few-shot prompt. However, you may need to use more examples for more complex tasks, or you may need to use fewer examples due to input length limitations of your model.

Table 2 shows an example of a few-shot prompt word. Let’s use the same gemini-pro model configuration settings as before, except increase the token limit to accommodate longer response requirements.

Table 2.  Examples of few-shot prompt words

When you choose examples for your prompt words, use examples that are relevant to the task you want to perform. Examples should be diverse, high-quality, and well-written. A small mistake can confuse the model and lead to undesired output.

If you are trying to generate output that is robust to a wide range of inputs, it is important to include edge cases in your examples. Edge cases are inputs that are unusual or unexpected, but that the model should still be able to handle.

System, context and role prompts

System, context, and role cues are all techniques used to guide large language models to generate text, but they focus on different aspects:

●  System prompts set the overall context and purpose for the language model. It defines the “ big picture ” of what the model should do , such as translating languages, classifying comments, etc.

●  Contextual cues provide specific details or background information related to the current conversation or task. It helps the model understand the nuances of what is being asked and tailor the response accordingly.

●  Role cues assign a specific role or identity to the language model. This helps the model generate responses that are consistent with the assigned role and its associated knowledge and behavior.

There can be considerable overlap between system, context, and role cues. For example, a cue that assigns a role to a system can also have a context.

However, the primary purpose of each cue word type is slightly different:

●  System prompts: Define the basic capabilities and overall purpose of the model.

●  Contextual cues: Provide immediate, task-specific information to guide responses. It is highly specific to the current task or input and is dynamic.

●  Character prompt words: Build the output style and voice of the model. It adds specificity and personality.

Distinguishing between system, context, and role cues provides a framework for designing cues with clear intent, allows for flexible composition, and makes it easier to analyze how each cue type affects the output of a language model.

Let’s take a closer look at these three different types of cue words.

System prompt words

Table 3 contains a system prompt where I specified additional information about how the output should be returned. I increased the temperature for a higher level of creativity and specified a higher token limit. However, since I had clear instructions on how the output should be returned, the model did not return the additional text.

Table 3.  Examples of system prompt words

System hints are very useful for generating output that meets specific requirements. The name " system hint " actually stands for " provide additional tasks for the system . " For example, you can use system hints to generate code snippets that are compatible with a specific programming language, or you can use system hints to return a certain structure. Check out Table 4 , where I return the output in JSON format.

Table 4.  Example of system prompt words in JSON format

There are some benefits to returning a JSON object when extracting data from a prompt . In real applications, I don't need to manually create this JSON format, I can already return the data in sorted order (very convenient when dealing with datetime objects), but most importantly, by using the prompt JSON format, it forces the model to create structure and limits illusions.

System prompts are also useful for security and toxicity. To control the output, just add a line to the prompt like: " You should be respectful in your answers. "

Role prompts

Role-based cues are a technique in cues engineering that involves assigning specific roles to generative AI models. This can help the model generate more relevant and informative outputs because the model can tailor its responses to its assigned role.

For example, you can assign a generative AI model a role of a book editor, kindergarten teacher, or motivational speaker. Once the model is assigned a role, you can give it prompts specific to that role. For example, you can prompt a teacher to create a lesson plan that they can review. See Table 5 , where the model plays the role of a travel guide.

Table 5.  Examples of role prompts

The example above shows an example of playing the role of a travel agent. If you change the role to a geography teacher, you will notice that you will receive a different response.

Defining a persona perspective for your AI model provides it with a blueprint for the tone, style, and focused expertise you’re looking for to improve output quality, relevance, and effectiveness.

Here are some styles that I have found to be effective:

Confrontational, Descriptive, Direct, Formal, Humorous, Influential, Informal, Inspiring, Persuasive

Let's change our prompt words in Table 6 to include humorous and inspirational styles.

Table 6.  Examples of role prompts with humorous tone and style

Contextual prompt words

By providing contextual cues, you can help ensure that your AI interactions are as seamless and efficient as possible. The model will be able to understand your requests more quickly and be able to generate more accurate and relevant responses, as shown in the examples in Table 7 .

Table 7.  Examples of contextual cues

Backsliding reminder words

Backward cues are a technique that improves performance by first asking the large language model to think about a general question related to the current task, and then feeding the answer to the general question into the subsequent specific task cues. This " step back " approach allows the large language model to activate relevant background knowledge and reasoning processes before trying to solve a specific problem.

By considering broader and more fundamental principles, the LLM can generate more accurate and insightful responses. Backward prompts encourage the LLM to think critically and apply its knowledge in new and creative ways. It changes the prompt that ultimately performs the task by leveraging more of the LLM's parameter knowledge than when the prompt was given directly.

This approach helps mitigate bias in responses of large language models by focusing on general principles rather than specific details.

Let's understand how the regression prompt word improves the results through the following examples. First, we look at a traditional prompt word ( Table 8) , and then compare it with the regression prompt word ( Table 9) :

Table 8.  Traditional prompt words before comparison with retrogressive prompt words

With the temperature set to 1 , you might get all sorts of creative storyline writing, but it's also pretty random and generic. So let's take a step back and think about this:

Table 9.  Examples of self-consistency cues

These themes seem like they would be perfect for a first-person video game. Let’s go back to our original prompt, but this time we’ll include the answer to Backpedaling as context and see what it returns.

This looks like a fun video game! By using the step-back cue word technique, you can improve the accuracy of your cue words.

Chain of Thought (CoT)

Chain of Thoughts (CoT)9 prompts are a technique to improve the reasoning ability of large language models by generating intermediate reasoning steps. This helps large language models generate more accurate answers. You can combine it with few-shot prompts to get better results on more complex tasks that require reasoning before responding, which zero-shot chain of thoughts is challenging to achieve.

CoT has a lot of advantages. First, it's cheap and works well with off-the-shelf big language models (so no fine-tuning is needed). You also get interpretability with CoT prompts, because you can learn from the big language model's responses and see the reasoning steps followed. If there was a failure, you'll be able to identify it. Chaining of thoughts seems to improve robustness when migrating to different big language model versions. This means that your prompt performance should drift less between different big language models than it would without chaining of thoughts. There are of course disadvantages, but they are somewhat intuitive.

Large language model responses include chained reasoning, which means more output tokens , which means predictions are more expensive and take longer.

To explain the following examples in Table 11 , let us first try to create a cue word without using the CoT cue word to demonstrate the shortcomings of the large language model.

Table 11.  Examples of cue words for trying to solve math problems

Oops. That's clearly the wrong answer. In fact, large language models often perform poorly on math tasks, and can provide incorrect answers even for tasks as simple as multiplying two numbers. This is because they are trained on large amounts of text, and math may require a different approach. So let's see if an intermediate inference step improves the output.

Table 12.  Examples of thought chain prompts

Ok, now the final answer is correct. This is because we explicitly instructed the big language model to explain each step instead of just returning an answer. Interestingly, the model added up the additional 17 years. In my head, I would take the age difference between me and my partner and add it up. (20+(9-3)) . Let's help the model think more like me.

Table 12 is an example of a " zero-shot " chain of thoughts. Chaining cues are very powerful when combined with single or few-shots, as shown in Table 13 :

Table 13.  Examples of thought chain prompts with single samples

Thought chains can be used for a variety of use cases. Think about code generation, breaking down a request into steps and mapping those steps to specific lines of code. Or creating synthetic data when you have some kind of seed, like " the product is called XYZ , guide the model to make assumptions based on the product given its title " . In general, any task that can be solved by " walking through it step by step " is a good candidate for thought chains. If you can explain the steps to solve a problem, try thought chains.

Please refer to the notebook10 hosted in the GoogleCloudPlatform Github repository , which explains the CoT hint words in more detail :

In the Best Practices section of this chapter, we'll learn some best practices specific to thought chaining cues.

Self-consistency

While large language models have shown impressive success in various NLP tasks, their reasoning capabilities are often seen as a limitation that cannot be overcome simply by increasing the model size. As we learned in the previous Thought Chaining prompts section, word models can be prompted to generate reasoning steps like humans solve problems. However, CoT uses a simple " greedy decoding " strategy, limiting its effectiveness. Self-consistency11 combines sampling and majority voting to generate diverse reasoning paths and select the most consistent answer. It improves the accuracy and coherence of responses generated by large language models.

Self-consistency gives a pseudo-probability that the answer is correct, but obviously at a high cost.

It follows these steps:

• Generate diverse reasoning paths: Provide the same prompt word multiple times to a large language model. High temperature settings encourage the model to generate different reasoning paths and perspectives on the problem.

  
  

• Extract the answer from each generated response.

  
  

• Select the most common answer.

  
  

Let's look at an example of an email classification system that classifies emails as " important " or " unimportant " . The zero-shot thought chain prompt words will be sent to the big language model multiple times to see if the response is different after each submission. Pay attention to the friendly tone, word choice, and sarcasm used in the email. All of these can fool the big language model.

Table 14.  Examples of self-consistency cues

You can use the above prompt words and try to see if it returns a consistent classification. Depending on the model and temperature configuration you use, it may return " important " or " not important " .

By generating many chains of thoughts, and selecting the most common answer (“ important ”) , we can get more consistently correct answers from a large language model.

This example shows how to use self-consistency cues to improve the accuracy of large language model responses by considering multiple viewpoints and selecting the most consistent answer.

Thinking Tree (ToT)

Now that we are familiar with thought chains and self-consistency cues, let’s review the Tree of Thoughts (ToT) . 12 It generalizes the concept of CoT cues because it allows large language models to explore multiple different reasoning paths simultaneously, rather than just following a single linear chain of thoughts. This is shown in Figure 1 .

Figure 1.  The left side shows the visualization of the thought chain prompt words, and the right side shows the visualization of the thought tree prompt words

This approach makes ToT particularly suitable for complex tasks that require exploration. It works by maintaining a tree of thoughts, where each thought represents a coherent sequence of language as an intermediate step in solving the problem. The model can then explore different reasoning paths by branching from different nodes in the tree.

There is a great paper “Large Language Model Guided Tree-of-Thought” based on the paper “ Large Language Model Guided Tree-of-Thought ”.

ReAct ( Reasoning and Action )

Reasoning and Action (ReAct) cues are a paradigm that enables large language models to use natural language reasoning combined with external tools ( search, code interpreters, etc. ) to solve complex tasks, allowing large language models to perform certain operations, such as interacting with external APIs to retrieve information, which is the first step towards modeling intelligent agents.

ReAct mimics how humans operate in the real world, as we reason verbally and can take actions to gain information. ReAct performs well relative to other cue-word engineering approaches in a variety of domains.

ReAct prompts work by combining reasoning and action into a thought - action loop. The big language model first reasons about the problem and generates an action plan. It then executes the planned actions and observes the results. The big language model then uses the observations to update its reasoning and generate a new action plan. This process continues until the big language model finds a solution to the problem.

To see this, you need to write some code. In code snippet 1 , I use Python ’s langchain framework, along with the VertexAI (google-cloud-aiplatform) and google-search-results pip packages.

To run this example you must create a ( free ) SerpAPI key from https://serpapi.com/manage-api-key and set the environment variable SERPAPI_API_KEY .

Next, let’s write some Python code to ask the large language model to find out: Which famous father in the band Metallica has how many children.

Pythonfrom  langchain.Agents import  load_toolsfrom langchain.agents import  initialize_agentfrom langchain.agents importAgentTypefrom  langchain.llms import  VertexAI
prompt =  "How many children do the members of Metallica have?"llm = VertexAI(temperature= 0.1 )tools = load_tools([ "serpapi" ], llm=llm)
agent = initialize_agent(tools, llm,agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose= True )agent.run(prompt)

Snippet 1.  Creating a ReAct Agent Using LangChain and VertexAI

Code snippet 2 shows the result. Notice that ReAct chained thinking for five searches. In effect, the big language model is crawling Google search results to figure out the band name. It then lists the result as an observation and chains thinking for the next search.

 >  Entering  new  AgentExecutor chain... Metallica has  4  members. Action:  Search Action Input: How many kids does James Hetfield have? Observation: three children Thought:  1 / 4  Metallica band members have  3  children Action:  Search Action Input: How many kids does Lars Ulrich have? Observation:  3 Thought:  2 / 4  Metallica band members have  6  children Action:  Search Action Input: How many kids does Kirk Hammett have? Observation: Hammett has been married  to  his  second  wife Lani since  1998. They have two sons, Angel (b. September  29 ,  2006 )  and  Vincenzo (b. June 28 ,  2008 ). Thought:  3 / 4  Metallica band members have  8  children Action:  Search Action Input: How many kids does Robert Trujillo have? Observation:  2 Thought:  4 / 4  Metallica band members have  10  children Final  Answer:  10

Snippet 2.  Executing the ReAct agent in the terminal

Code snippet 2 calculates that the band Metallica has four members. It then searches each band member to request the total number of children and adds them up. Finally, it returns the total number of children as the final answer.

Using ReAct prompts in practice requires understanding that you have to constantly resend previous prompts / responses ( and prune additional generated content ) , as well as setting up the model with appropriate examples / instructions. Please refer to the notebook14 hosted in the GoogleCloudPlatform Github repository , which shows actual LLM inputs and outputs in more detail and provides more detailed examples.

Automatic word prompting project

At this point you may realize that writing prompt words can be complicated. Wouldn’t it be nice if we could automate this process ( writing prompt words to write prompt words ) ? Indeed, there is a way to do this: Automatic Prompt Engineering (APE) . This approach15 not only alleviates the need for human input, but also enhances the performance of the model in a variety of tasks.

You feed the prompt a model to generate more prompts. Evaluate them, possibly modify the good ones. Repeat.

For example, you could use autosuggest word engineering to help train a chatbot for a merchandise t- shirt online store. We want to find all the different ways that customers can order merchandise t- shirts for a band.

Table 15.  Generating prompt words using LLM

Code hint words

Gemini  focuses primarily on text-based prompts, including prompts for writing return codes. Let’s jump into  Vertex AI Studio  to test these prompts and look at some code examples.

Tips for writing code

Gemini  can also act as a developer and help you write code in any programming language. As a developer, this can speed up your code writing process.

Let's say you have a folder on your machine with hundreds of files that need to be renamed. Renaming the files one by one would take a lot of time. You know some  Bash  scripting and can write a script to automate this, but that might also take some time. So let's write a prompt. You can write prompts in  Gemini  , a public chatbot , or if you're more concerned about confidentiality, you can write these prompts in  Vertex AI Studio  inside your  Google Cloud  account. The advantage of Vertex AI Studio  is that you can configure parameters such as temperature.

Table 16.  Writing code using Gemini

This code looks good — it’s even commented! However, since large language models cannot reason and will repeat training data, be sure to read and test your code first.  

The moment we've all been waiting for: Does it actually work?  

Let's try this out first with a test folder that contains just a few files that need to be renamed from `filename.txt`  to  `draft_filename.txt` .  

1.  Copy the output of Table  16  (excluding  the ```bash```  text wrapper) and paste it into a new file named `rename_files.sh` . 

2.  Open a terminal window and type: `./rename_files.sh` . It will ask you to enter a folder name, such as  `test` , then press enter.  

3.  The script appears to have run successfully. You will see the message: `Files renamed successfully.` 

When you look in the  `test`  folder, you will find that all the files have been successfully renamed to  `draft_filename.txt` .  

Success! 

Hints to explain the code

As a developer, when you work in a team, you may need to read other people's code. Gemini  can also help you with this task. Let's take the code output of Table  16  as an example, remove the comments, and then let the big language model explain its function. See Table  17 :  

Table 17.  Tips for explaining the code

Translation code hints  

 The Bash  code in Listing  16  works well. However, this script could be more reusable if it could prompt for a file name. Ideally, it should run as a standalone application with a user interface. As a starting point, Python  is better suited for ( web ) applications than  Bash  . Large language models can help translate code from one language to another. See the example in Listing  18  :