Prompt Engineering Techniques

1. The Art and Science of Prompt Engineering

Before diving into specific techniques, it's crucial to understand the mental model behind prompting. It's easy to think of it as just asking questions, but it's much more.

A well-structured prompt guides the model's prediction process. While prompts can be very complex, they generally contain four key components.

2. Technique 1: Role-Playing (Persona Prompting)

One of the easiest and most effective ways to improve an LLM's output is to give it a role. By assigning a persona, you narrow the model's focus and guide its tone, vocabulary, and style.

Think about it: asking a "senior site reliability engineer" for an apology email will yield a very different result than asking a generic AI.

Let's apply this in code. Building on our script from the previous lesson, we can add a system message to assign a role.

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()




# The system message assigns a persona to the model.
system_prompt = "You are a senior Python developer. Your role is to provide clear, concise, and expert-level advice on Python programming. You always provide code examples."

user_prompt = "Explain the difference between a list and a tuple in Python."

try:
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_prompt}
        ],
        temperature=0.7,
        max_tokens=250
    )

    answer = response.choices[0].message.content
    print(f"Expert Python Dev:\n{answer}")

except Exception as e:
    print(f"An error occurred: {e}")

By setting this persona, we guide the model to produce an answer that is technically accurate and includes code, which is exactly what a senior developer would do.

3. Technique 2: Zero-Shot Prompting

Zero-shot prompting is the most basic form of interaction: you give the model a task to perform without providing any examples of how to do it. You have already been doing this!

A prompt like "Translate 'hello' to French" is a zero-shot prompt. It relies entirely on the model's pre-existing knowledge to understand and execute the instruction.

Zero-shot prompting is best for straightforward tasks that are well-represented in the model's training data, such as summarization, translation, or general knowledge questions.

4. Technique 3: Few-Shot Prompting

What if the task is novel, or you need the output in a very specific format that the model might not produce by default? This is where few-shot prompting shines.

In few-shot prompting, you provide one or more examples (shots) of the task being performed. This isn't fine-tuning the model; it's a form of in-context learning where the model uses the examples within the prompt to understand the pattern you want it to follow.

• One-shot: Providing a single example.
• Few-shot: Providing multiple examples.

Implementing Few-Shot Prompting in Code

Let's try a practical task: extracting structured data (JSON) from unstructured text. This is a common task in AI development. A zero-shot prompt might work, but a few-shot prompt will give us much more reliable and consistently formatted results.

We provide examples by structuring the messages list with user/assistant turn pairs.

import os
import json
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()




# The system message sets the overall goal.
system_prompt = "You are an expert data extraction assistant. Your task is to extract user information from text and return it as a clean JSON object."




# The text we want to extract data from.
text_to_extract = "Michael Johnson is a 42-year-old software architect from Seattle."

try:
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {"role": "system", "content": system_prompt},
            



            # --- Example 1 (One-Shot) ---
            {"role": "user", "content": "Extract user info from: 'Sarah Lee is 29 and works as a product manager in San Francisco.'"},
            {"role": "assistant", "content": json.dumps({"name": "Sarah Lee", "age": 29, "occupation": "product manager", "city": "San Francisco"})},
            



            # --- Example 2 (makes it Few-Shot) ---
            {"role": "user", "content": "Extract user info from: 'David Chen, a 35-year-old doctor, resides in Boston.'"},
            {"role": "assistant", "content": json.dumps({"name": "David Chen", "age": 35, "occupation": "doctor", "city": "Boston"})},




            # --- Our actual request ---
            {"role": "user", "content": f"Extract user info from: '{text_to_extract}'"}
        ],
        temperature=0.1, # Low temperature for factual, consistent output
    )

    extracted_json = response.choices[0].message.content
    print("Extracted Data:")
    print(json.dumps(json.loads(extracted_json), indent=2))

except Exception as e:
    print(f"An error occurred: {e}")

By providing two complete examples, we teach the model the exact JSON structure we expect. It learns the keys (name, age, etc.) and the data types, making the output for our new text highly predictable and reliable.

5. Summary of Core Techniques

You've now learned the three most fundamental prompt engineering techniques.

Key best practices to remember:

• Be Specific: Ambiguity is your enemy. Clearly define the format, length, tone, and style you want.
• Provide Context: Give the model the background information it needs to do the task well.
• Show, Don't Just Tell: When the format is critical, use few-shot examples to demonstrate the desired output.

Conclusion

In this lesson, you've moved beyond simply calling an API to strategically guiding an LLM's behavior. You've learned that prompting is a form of programming and that by using specific techniques, you can elicit far more accurate and useful responses.

Key Takeaways:

• Prompting as Programming: You should think of LLMs as prediction engines and your prompts as programs that guide their output.
• Role-Playing: Assigning a persona via the system message is a simple yet powerful way to control the model's tone and expertise.
• Zero-Shot Prompting: This is your go-to for simple, well-defined tasks where the model's general knowledge is sufficient.
• Few-Shot Prompting: This is essential for tasks requiring a specific output format or style. By providing examples, you teach the model the desired pattern in-context.

Preview of the Next Lesson:
Prompt engineering is incredibly powerful, but even the best prompts are limited by the model's training data, which is static and can be outdated. What if you need the model to answer questions about very recent events or your company's private documents? In our next lesson, we will explore Retrieval-Augmented Generation (RAG), an architecture that allows you to provide the LLM with external, up-to-date information at the time of prompting.