Prompt engineering comes in handy when fine-tuning is too costly. Fine-tuning needs a large, clean dataset, lots of computing power, and special MLOps skills. For many projects, startups, or academic labs, this just isn’t practical.
But what if I told you the model you already have is likely powerful enough? You don’t need to be a model trainer; you just need to direct it the right way. This is the art and science of prompt engineering.
Let’s go through a detailed guide to prompt engineering for using LLMs as an AI/ML Engineer.
Your Prompting Toolkit
Prompt Engineering for AI/ML Engineers isn’t just about asking better. It’s about structuring your request. Here are the core techniques every AI/ML student should master.
1. Roles and Clear Instructions (Zero-Shot)
Never assume the LLM knows what you want. Be explicit. The easiest way to do this is by assigning a persona or role. This is called Zero-Shot Prompting, you’re asking for a task without giving any prior examples.
For example, here’s one bad prompt:
Summarize this article.
It’s bad because it doesn’t describe: How long? For whom? What style?
Here’s an example of a good prompt:
You are an expert financial analyst. Your audience is a group of busy executives who have no time for fluff.
Summarize the following earnings report into five crucial bullet points. Focus only on:
1. Year-over-year revenue growth
2. Changes in profit margin
3. Key risks mentioned in the forward-looking statement
The output MUST be in a bulleted list.
[Article text here...]
2. Few-Shot Learning
This is your single most powerful alternative to fine-tuning.
Instead of just telling the model what to do, you show it 2-5 examples of the exact input-output format you want. This is called in-context learning, and it works incredibly well for tasks like classification, data extraction, and style imitation.
Let’s say you want to classify customer support tickets. Here’s an example of a good prompt using the few-shot method:
Classify the sentiment of the following user feedback into one of three categories: Positive, Negative, or Neutral.
Text: "I am so in love with the new update, it's perfect!"
Sentiment: Positive
###
Text: "The app keeps crashing after I open it. This is unusable."
Sentiment: Negative
###
Text: "I guess the new button color is fine."
Sentiment: Neutral
###
Text: "I can't find the login page and your support team is not responding!"
Sentiment:
The model will see the pattern and almost certainly reply with Negative. You’ve trained it in context, with zero data pipelines or GPU costs.
3. Chain-of-Thought (CoT) Prompting
LLMs are smart, but they’re also lazy. They will often jump to an intuitive-but-wrong answer for complex problems. Chain-of-Thought (CoT) prompting forces the model to slow down and show its work, which dramatically increases accuracy on logic, math, and planning tasks.
Here’s an example of a bad prompt:
A bat and a ball cost $1.10 in total. The bat costs $1.00 more than the ball. How much does the ball cost?
Many LLMs will incorrectly answer $0.10.
Here’s an example of a good prompt for such scenarios using the Chain-of-Thought Prompting:
A bat and a ball cost $1.10 in total. The bat costs $1.00 more than the ball. How much does the ball cost?
Let's think step-by-step.
A Practical Python Example for Prompt Engineering
Let’s tie this together. Here is how you’d implement a Few-Shot Prompt in a Python pipeline using the API structure. This is how you build reliable systems without fine-tuning:
# This example uses the openai client structure, but the
# prompting principle works with Anthropic, Cohere, Llama, etc.
from openai import OpenAI
# It's good practice to set this as an environment variable
client = OpenAI(api_key="YOUR_API_KEY")
def classify_sentiment(user_text):
"""
Classifies user sentiment using a Few-Shot prompt.
This is our "in-context" learning.
"""
# We build our prompt "payload" with clear examples
# The 'system' prompt sets the persona and overall goal
system_prompt = """
You are a helpful assistant that classifies the sentiment of user feedback.
You must only respond with one of the following three options:
Positive, Negative, or Neutral.
"""
# The 'user' prompt contains our examples and the new query
# Using '###' is a common delimiter to separate examples
user_prompt_content = f"""
Here are some examples:
Text: "This movie was incredible!"
Sentiment: Positive
###
Text: "The food was cold and the service was slow."
Sentiment: Negative
###
Text: "It's an okay product, not great."
Sentiment: Neutral
###
Now, classify the following text:
Text: "{user_text}"
Sentiment:
"""
try:
response = client.chat.completions.create(
model="gpt-4o", # Or your model of choice
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt_content}
],
temperature=0, # We want a deterministic, not creative, answer
max_tokens=10
)
# The model's response will just be the completion
# e.g., "Negative"
return response.choices[0].message.content.strip()
except Exception as e:
print(f"An error occurred: {e}")
return None
# --- Let's test it ---
new_feedback = "I'm absolutely amazed by the build quality and speed!"
sentiment = classify_sentiment(new_feedback)
print(f"Feedback: '{new_feedback}'\nSentiment: {sentiment}")
new_feedback_2 = "Why can't I find the settings button? This is frustrating."
sentiment_2 = classify_sentiment(new_feedback_2)
print(f"Feedback: '{new_feedback_2}'\nSentiment: {sentiment_2}")Expected Output:
Feedback: 'I'm absolutely amazed by the build quality and speed!'Sentiment: PositiveFeedback: 'Why can't I find the settings button? This is frustrating.'Sentiment: Negative
Final Words
Prompt engineering isn’t just a hack or a trick. It’s a new form of communication, a new kind of literacy. It forces you to have ultimate clarity of thought. You can’t get a clear answer if you ask a fuzzy question. I’ve found that the process of writing a great prompt often clarifies my own thinking in ways I never expected.
So, as an AI/ML Engineer, before you jump into the deep, expensive side of fine-tuning, try being a great conversationalist first. Here are some resources that you can follow to learn more about prompt engineering:
I hope you liked this article on a detailed guide to prompt engineering for using LLMs. Feel free to ask valuable questions in the comments section below. You can follow me on Instagram for many more resources.
