7 Advanced Prompt Engineering Techniques for LLMs | ExcelR

What Makes Advanced Prompt Engineering Different?

Have you ever asked a language model a complex question only to receive a vague or incorrect answer? Or have you noticed that slightly rewording your question completely changes the quality of the response? These variations occur because LLMs are extremely sensitive to how you phrase your prompts.

Let's explore powerful techniques to dramatically improve your LLM's performance on challenging tasks like reasoning, problem-solving, and decision-making.

Basic prompting involves simple instructions or questions. Advanced techniques provide structured guidance that helps LLMs break down complex problems into manageable steps. Think of it as the difference between asking someone to solve a math problem versus walking them through a solution strategy step by step.

The right prompting technique can transform an LLM from a simple text generator into a sophisticated reasoning engine without changing the underlying model.

7 Prompting Techniques You Can Try Right Now

Below is a list of 7 prompting techniques with examples you can try out and improve your LLM's output (be ready to be shocked at how good LLMs can get if you know how to prompt!):

1. Chain-of-Thought (CoT) Prompting

Chain-of-Thought prompting guides LLMs in generating intermediate reasoning steps before arriving at a final answer. This approach works particularly well for mathematical problems, logical reasoning, and complex decision-making.

You can use two main variants:

• Few-shot CoT: You provide examples that include the question and a step-by-step solution before asking your actual question.
• Zero-shot CoT: You simply add "Let's think step by step" to your prompt, encouraging the model to break down its reasoning.

For example, when asking a complex math question, instead of just requesting the answer, you might prompt:

Q: Roger has five tennis balls. He buys two more cans of tennis balls. Each can has three tennis balls. How many tennis balls does he have now?

A: Let's think step by step.

In Fig. 1, you can see the difference between standard prompting and Chain-of-Thought prompting, demonstrating how the step-by-step approach leads to more accurate answers.

2. Tree-of-Thoughts (ToT) Prompting

While Chain-of-Thought creates a linear reasoning path, Tree-of-Thoughts explores multiple potential solution paths simultaneously. This technique is especially valuable for problems with multiple possible approaches or those requiring planning ahead.

When you implement ToT, you'll guide the model through these steps:

1. Generating several "thoughts" (partial solutions) at each step
2. Evaluating the quality of each thought
3. Exploring the most promising branches further
4. Backtracking when a path proves unfruitful

ToT can achieve significantly higher success rates than linear approaches for complex problem-solving, like puzzles or games. For instance, on the "Game of 24" math puzzle, ToT achieved a 74% success rate compared to just 4-9% with standard methods.

In Fig 2, you can see a visualisation of a Tree-of-Thoughts approach, where multiple reasoning branches are explored before settling on the optimal solution path.

3. Few-Shot Prompting

Few-shot prompting involves providing the LLM with examples of the desired input-output pattern. Instead of explicitly instructing the model, you show it examples of what you want.

The model understands the expected pattern by showing several examples first, and can continue it for new inputs. This technique requires no special instructions, just examples that display the desired behaviour. You'll see this in Fig. 3.

4. Self-Consistency

Self-consistency enhances the chain of thought by generating multiple reasoning paths and obtaining the most consistent answer. Rather than relying on a single chain of thought, which might contain errors, you can have the model produce several solutions and choose the most frequent answer.

The process works by:

1. Generating multiple CoT solutions for the same problem
2. Extracting final answers from each reasoning chain
3. Selecting the most common answer as the final result

Self-consistency improves accuracy by generating multiple reasoning paths and selecting the most consistent result. This approach helps you overcome reasoning errors that might occur in any single solution attempt.

5. ReAct: Reasoning and Acting

ReAct combines verbal reasoning with actions to solve complex tasks. It's particularly effective when the model needs to interact with external environments or tools.

When you implement ReAct, you'll follow this pattern:

1. Thought: The model reasons about the current situation
2. Action: It decides on an action to take (like searching for information)
3. Observation: It observes the result of that action
4. Thought: It reasons again based on the new information

In Fig 5, you can see how ReAct combines reasoning and actions in an iterative process (it's breaking the job/task into manageable steps here) to solve complex problems. You'll observe how it:

• improves problem-solving through structured reasoning
• makes it easier for you to do complex tasks
• creates transparency in the reasoning process
• reduces errors by breaking down problems into manageable steps

6. Reflection and Self-Improvement

Reflection techniques enhance LLM performance by encouraging models to evaluate and improve their responses. This approach works great for programming tasks and complex reasoning problems.

The key steps include:

1. Generate an initial solution
2. Evaluate the solution and identify potential issues
3. Generate reflective feedback
4. Produce an improved solution based on the reflection

For example, in a Python programming task, the reflection process might look like:

In Figs. 6, 7, and 8, you can see how the reflection process works to improve initial solutions through self-critique and revision.

7. MRKL (Modular Reasoning, Knowledge, and Language)

MRKL (pronounced "miracle") will transform how you interact with AI systems. When you've pushed the limits of the techniques we've covered so far, MRKL offers you a powerful new approach that combines neural computation with symbolic tools and external knowledge bases.

Using MRKL gives your LLM access to a team of specialised experts and tools that it can call upon whenever needed. This means you're no longer limited by what's encoded in the model's weights.

When you implement an MRKL system, you're essentially creating an AI architecture with these components:

1. A central LLM that serves as your "conductor," orchestrating the process
2. Multiple specialised modules you can customise (calculators, knowledge bases, search engines, etc.)
3. A router that intelligently determines which of your modules should handle each part of a complex task

In Fig 9, you'll see a simplified view of the MRKL system's architecture. The central circle represents the LLM that acts as your system's "brain," while the dotted lines indicate connections to various specialised modules. The central LLM coordinates with external tools and knowledge bases. Let's see the next step.

In Fig 10, you'll see how your LLM breaks down your complex question about NYC emissions. Notice how it identifies multiple capabilities needed, i.e., population data retrieval, emissions calculations, and comparative analysis, from your single question. This initial analysis helps the LLM to decide which specialiszed modules to activate.

In Fig 11, you'll see your Knowledge Base module in action, retrieving key facts you need for solving the problem: NYC's population of 8.8 million, vehicle emissions data, and Luxembourg's annual carbon output.

In Fig 12, you'll see your Calculation module performing precise mathematical operations. Notice how it breaks down the complex calculation into manageable steps.

In Fig 13, you'll see your Comparison module analyszing the relationship between two emission values. The module calculates NYC emissions and Luxembourg's annual output to determine the ratio and percentage difference.

In Fig 14, you'll see how all the separate module outputs come together to form your final, comprehensive answer.

How do you choose the right technique?

Different techniques excel at different tasks:

• Use Chain-of-Thought for mathematical reasoning, logical deduction, and when you need to break a problem into clear sequential steps
• Try Tree-of-Thoughts for complex planning problems, puzzles, or when there are multiple valid approaches to explore
• Apply Few-Shot when you have examples of the desired behaviour, and the task pattern is consistent
• Implement Self-Consistency when accuracy is critical and you can afford multiple generation attempts
• Use ReAct when external information or tools are needed to solve a problem, or for multi-step decision-making tasks
• Try Reflection for programming, writing tasks, or any situation where evaluation and improvement cycles would help
• Apply Structured Prompting for analytical tasks requiring thorough consideration of multiple factors
• Use MRKL when you're tackling problems that require specialised expertise across multiple domains simultaneously.

Conclusion

When you're working with AI, how you ask questions matters just as much as the tool you're using. The prompt techniques we've covered give you practical ways to get better answers from LLMs without needing to change the models themselves.

You might find Chain-of-Thought works best when you need to break down complex math or reasoning problems. Tree-of-Thoughts can help when you're exploring multiple solution paths for puzzles or planning challenges. And when you need specialised expertise across different fields, MRKL approaches connect your questions to the right tools and knowledge.

Recent breakthroughs in Generative AI and Large Language Models have shown that even simple prompting changes can yield impressive improvements. Just adding "*Let's think step by step*" to your question can dramatically enhance the quality of responses. Crazy right?

As you try these approaches with your projects, you'll develop a sense for which techniques work best in different situations.

As you try these approaches with your projects, you'll develop a sense of which techniques work best in different situations. Start simple, then add more sophisticated methods when needed. Even small changes to how you phrase your questions can lead to much better results.