Prompt Guide

1. Introduction

Prompt engineering is the process of designing and refining prompts to guide Large Language Models (LLMs) toward producing desired outputs. Whether you are a college student exploring AI for the first time or an aspiring AI engineer who needs to integrate LLMs into real-world applications, a solid grounding in prompt engineering is crucial.

In this guide, we'll walk through key concepts, parameters, and prompting techniques. We'll also discuss best practices and common pitfalls. By the end, you should understand how to harness LLMs more effectively-whether for text summarization, classification, code generation, or more creative tasks.

For end-to-end AI workflows, check out our AI Agents guide.

Why Prompt Engineering Matters

As AI becomes increasingly integrated into our daily lives and work processes, the ability to effectively communicate with these systems becomes a critical skill. Consider these real-world applications:

• Content Creation: Marketing teams using AI to generate blog posts, product descriptions, and social media content that maintains brand voice
• Code Development: Developers leveraging AI assistants to debug code, generate tests, or implement features based on specifications
• Data Analysis: Analysts using LLMs to interpret complex datasets, generate SQL queries, or summarize findings for stakeholders
• Customer Support: Companies implementing AI chatbots that can accurately understand and respond to customer inquiries
• Education: Teachers creating personalized learning materials or assessment questions tailored to specific learning objectives

In each case, the difference between a mediocre and an exceptional AI interaction often comes down to how well the human has engineered their prompts. This guide will equip you with the techniques to craft prompts that yield precise, relevant, and useful outputs across these diverse applications.

2. LLM Output Configuration

Before diving into specific prompt styles, it's important to understand the configurations that affect LLM outputs. These parameters significantly influence how the model responds and can be adjusted to match your specific needs.

Core Parameters

• Output length (Max tokens): Controls how many tokens the LLM can generate. Generating more tokens can produce more detailed responses but is more expensive and potentially slower.
  Example: For summarizing a long document, you might set max_tokens=150 for a brief overview or max_tokens=500 for a more comprehensive summary.
• Temperature: Governs the level of randomness in the model's output. A temperature of 0 is deterministic (greedy decoding), while higher temperatures lead to more diverse or unexpected results.
  Example: When generating SQL queries (temperature=0.1) vs. creative writing (temperature=0.8). Try this yourself by asking for a tagline for a coffee shop at different temperature settings.
• Top-K / Top-P (Nucleus Sampling): Determines how many tokens are considered in each step (top-K) or what cumulative probability mass the model can sample from (top-P). Both can be combined for finer control.
  Example: top_p=0.9 means the model will only consider tokens whose cumulative probability adds up to 90%, effectively filtering out less likely options.
• Frequency/Presence Penalty: Reduces the likelihood of repetition by penalizing tokens that have already appeared (frequency) or appeared at all (presence).
  Example: In long-form content generation, setting frequency_penalty=0.8 can help prevent the model from repeating the same phrases.

Optimal Settings for Common Tasks

Practical Examples

The key to mastering LLM configuration is experimentation. Start with the recommended settings for your task type, then gradually adjust parameters based on the outputs you receive. Keep a log of what works best for different scenarios in your specific application domain.

3. Prompting Techniques

{
  "size": "large",
  "type": "normal",
  "ingredients": ["tomato sauce", "ham", "pineapple"]
}

{
  "sentiment": "positive",
  "features_mentioned": ["meditation sessions"],
  "bugs_reported": ["audio cuts out mid-session"],
  "feature_requests": ["offline downloads"],
  "user_experience_rating": 4
}

"You are a helpful assistant. Classify the following review only as
'POSITIVE', 'NEGATIVE', or 'NEUTRAL', and provide no explanation."

"Act as a travel agent focusing on family-friendly experiences in London.
Suggest three day-trip ideas that are ideal for kids under 7."

"When I was 3, my partner was 3 times my age. Now I am 20.
How old is my partner? Let's think step by step."

4. Code Prompting

LLMs can generate, translate, and debug code across various programming languages. Mastering code-specific prompts can significantly enhance developer productivity and help solve complex programming challenges.

Common Code-Related Tasks

Effective Code Prompting Examples

Write a JavaScript function that calculates the Fibonacci sequence up to the nth term using memoization for efficiency. 

Think through the solution step by step, explaining each component:
1. First explain the Fibonacci sequence and why memoization helps
2. Then implement the function
3. Finally, provide an example of how to call the function

Make sure to include proper error handling and comments.

Debug the following Python code that's supposed to merge two sorted lists into a single sorted list, but it's not working correctly. The current output shows duplicate values and sometimes misses elements.

```python
def merge_sorted_lists(list1, list2):
    result = []
    i = j = 0
    
    while i < len(list1) and j < len(list2):
        if list1[i] < list2[j]:
            result.append(list1[i])
            i += 1
        else:
            result.append(list2[j])
            j += 1
    
    # Add remaining elements
    result.extend(list1[i:])
    result.extend(list2[j:])
    
    return result

# Test case
list1 = [1, 3, 5, 7]
list2 = [2, 4, 6, 8]
print(merge_sorted_lists(list1, list2))
```

First identify the bug, then explain why it's happening, and finally provide the corrected code.

Convert this Java code to TypeScript while improving its readability and implementing modern TypeScript features like:
- Proper type annotations
- Optional chaining
- Nullish coalescing
- Destructuring where appropriate
- Using ES6+ syntax

```java
public class UserManager {
    private Map<String, User> users = new HashMap<>();

    public User getUser(String id) {
        return users.getOrDefault(id, null);
    }

    public boolean addUser(User user) {
        if (user == null || user.getId() == null) {
            return false;
        }
        if (users.containsKey(user.getId())) {
            return false;
        }
        users.put(user.getId(), user);
        return true;
    }

    public List<String> getUserNames() {
        List<String> names = new ArrayList<>();
        for (User user : users.values()) {
            if (user.getName() != null) {
                names.add(user.getName());
            }
        }
        return names;
    }
}

public class User {
    private String id;
    private String name;
    private int age;
    private String email;

    public User(String id, String name, int age, String email) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.email = email;
    }

    public String getId() { return id; }
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getEmail() { return email; }
}
```

Please add comments explaining the TypeScript-specific improvements you've made.

Code Prompting Best Practices

• Be Specific About Requirements: Clearly outline functionality, edge cases, and performance considerations.
• Provide Context and Constraints: Mention target environment, framework versions, or any specific libraries to use or avoid.
• Request Explanations: Ask the LLM to explain its approach or reasoning behind certain implementation choices.
• Use Input/Output Examples: Include sample inputs and expected outputs to clarify requirements.
• Iterative Refinement: Start with a basic implementation and then iteratively ask for improvements or optimizations.
• Always Review Generated Code: Never blindly use AI-generated code without understanding it and testing thoroughly.

Remember that AI-generated code should be a starting point or assistant, not a replacement for software engineering expertise. Always validate the code's correctness, security, and performance before incorporating it into production systems.

5. Best Practices

• Provide Examples: Use one-shot or few-shot prompts whenever possible to anchor the model's output.
• Design with Simplicity: Keep prompts clear and concise. Overly verbose prompts can confuse LLMs.
• Be Specific About the Output: Indicate the desired format (JSON, bullet points, paragraphs, etc.) and style (formal, humorous, etc.).
• Use Instructions Over Constraints: Positive instructions are often more effective than long lists of "do not" constraints.
• Control Max Tokens: Either configure maximum tokens or explicitly ask for "tweet-length" or "3-sentence" responses.
• Use Variables in Prompts: Parameterize aspects (e.g., city name) to reuse the same prompt shape across different inputs.
• Experiment with Input & Output Formats: Try different ways of structuring your prompt and the answer you want.
• Document Attempts: Keep a record of prompt versions, model configs, successes, and failures.
• Leverage Chain of Thought & Reasoning: For more complex tasks, step-by-step reasoning or self-consistency can greatly improve results.

6. JSON & Schemas

Returning JSON (or other structured formats) can improve reliability and limit hallucinations. Consider including a schema in your prompt to structure the output. For instance:

"Return valid JSON following this schema:
{
  "movie_reviews": [
    {
      "sentiment": "POSITIVE|NEGATIVE|NEUTRAL",
      "name": "string"
    }
  ]
}"

However, generating long JSON can exceed token limits and risk truncation. Tools like json-repair can help fix malformed outputs.

7. Summary

Prompt Engineering is an essential skill for anyone looking to effectively utilize Large Language Models. From zero-shot tasks to advanced methods like Chain of Thought, ReAct, and Tree of Thoughts, the techniques here can help you systematically refine your interactions with LLMs.

Practical Applications

Continued Learning

The field of prompt engineering is rapidly evolving. To stay current:

• Experiment with different models to understand their unique capabilities
• Build a personal library of effective prompts for common tasks
• Document your approaches and learnings from each project
• Participate in prompt engineering communities and forums
• Stay updated on new research papers and techniques