Priyaranjan Kumar
June 3, 2025
5 Minutes read
A Practical Guide to Prompt Engineering: Getting the Best from Large Language Models
Large Language Models (LLMs) like ChatGPT, Claude, and Gemini are powerful tools that are changing how we work, create, and interact with technology. But getting them to do exactly what you want can sometimes feel tricky. That’s where Prompt Engineering comes in.
Think of it as giving clear instructions. Just as clear instructions lead to better results from a human assistant, well-crafted prompts lead to better results from an AI.
Who is this guide for?
This guide is designed for anyone who wants to get more out of LLMs, whether you’re a beginner curious about AI, a writer looking to enhance creativity, a developer building AI features, or a professional seeking to improve productivity. No deep technical knowledge is required—just a willingness to learn and experiment
What is Prompt Engineering?
Prompt engineering is the skill of writing good instructions (prompts) for LLMs. It’s about choosing the right words, format, and examples to guide the AI to give you the specific, high-quality answer you need.
Why bother learning this?
- Better Results: Get answers that are accurate, relevant, and in the format you need. Less trial-and-error!
- More Control: Steer the AI’s responses more effectively.
- Improved Efficiency: Get what you need faster.
- Unlock Creativity: Use AI for a broader range of tasks, from writing emails to generating code or creative stories.
- Safer AI: Help avoid unwanted outputs or biases by clearly defining constraints, desired perspectives, and factual grounding in your prompts.
The Basics: What Makes a Good Prompt?
- Be Clear and Specific:
- Tell the AI exactly what you want. Vague prompts get vague answers. Instead of “Tell me about dogs,” try “Write a short paragraph explaining the main responsibilities of owning a Modhoul Hound.”
- Specify the format. Do you want bullet points? A paragraph? A table? JSON? Tell the AI! (“Summarize the key points in a bulleted list.”)
- Give details. Include important information the AI needs to know. (“Write a formal email to a client about the project delay, mentioning the new deadline is Friday.”)
- Provide Context:
- Give background info. LLMs don’t know your specific situation unless you provide them with the information. (“I’m writing a blog post for beginners. Explain blockchain in simple terms.”)
- Assign a role (persona). This helps set the tone and style. (“Act as an experienced travel agent. Suggest a 7-day itinerary for Italy focused on history and food.”)
- Iterate and Refine:
- Don’t expect perfection on the first try. Prompting is often a trial-and-error process.
- Experiment- If you don’t get what you want, tweak the prompt. Try different wording, add more detail, or use a different technique (more on those next!). Adjust based on the AI’s response.
Prompting Techniques: Different Ways to Ask
There isn’t just one way to write a prompt. Here are some key techniques:
| Technique | Description | When to Use It | Example Snippet | Pros | Cons |
| Zero-Shot Prompting | Give instructions without any examples. | Simple tasks, common requests (translation, summarization, basic Q&A). | Translate ‘cat’ to Spanish. | Simple, quick. | Might not work well for complex or unusual tasks. |
| Few-Shot Prompting | Give a few examples of what you want in the prompt. | Complex tasks, specific formats/styles (sentiment analysis, code generation). | Input: happy -> Output: Positive\nInput: sad -> Output: Negative\nInput: excited -> Output: | Improves accuracy for tricky tasks, and guides style. | Needs good examples, take more effort to write |
| Chain-of-Thought (CoT) | Ask the LLM to “think step-by-step” before giving the final answer. | Problems requiring logic or reasoning (math problems, complex Q&A). | Q: Solve 5*3+10. Let’s think step-by-step. | Better reasoning shows the AI’s “thinking”. | It can be longer and may not work on all models. |
| Instruction Prompting | Give clear, direct commands or steps. | Tasks with specific steps (formatting text, extracting data, writing guides) | Summarize this text: [text] | Flexible, good for procedural tasks | Success depends heavily on instruction clarity. |
| Retrieval- Augmented Generation (RAG) | Let the LLM look up info from a specific source before answering. | Q&A requires current and specific data, reducing “made-up” facts. | Based on [document], answer: … | It is more accurate and uses up-to-date / private info. | Requires setting up access to the data source |
Examples
How are these techniques used?
- Summarizing Articles: Use instruction prompting (“Summarize this article [text] into 3 bullet points focusing on the main conclusions.”) or Few-Shot (provide examples of good summaries).
- Writing Content: Use instruction prompting with a persona (“Act as a witty marketing expert. Write 5 catchy slogans for a new eco-friendly coffee cup.”). Use few-shot to match the brand voice.
- Generating Code: Use instruction prompting (“Write a Python function that takes a list of strings and returns the longest string.”) or Few-Shot (give examples of desired code style).
- Answering Questions: Use RAG for questions needing current facts (“Based on our internal company knowledge base, what is the latest update on Project Phoenix?”). Use CoT for complex logic questions.
- Extracting Data: Use instruction prompting (“Extract the names and email addresses from this text [text] and format them as a CSV list.”).
- Classifying Text: Use zero-shot for simple tasks (“Classify this customer feedback as positive, negative, or neutral: [feedback text]”) or few-shot for more nuance.
Common Roadblocks (and How to Get Past Them)
Sometimes, prompts don’t work as expected. Here are common issues and fixes:
- Problem: Vague/Generic Answers
- Fix: Be more specific! Add details and context, and specify the desired format. (Principle: clarity & specificity)
- Problem: LLM Struggles with Complex Tasks
- Fix: Break it down! A pragmatic approach is to use Chain-of-Thought prompting (“Let’s think step-by-step”) or ask the LLM to handle one part at a time.
- Problem: Inconsistent Tone/Style
- Fix: Assign a persona (“Act as a…”) or provide examples using few-shot prompting.
- Problem: LLM “Makes Stuff Up” (Hallucinates)
- Fix: Use RAG to ground the LLM in facts. Ask it to cite sources. Double-check critical information.
- Problem: Asking Too Much at Once
- Fix: Simplify the prompt. Break complex requests into multiple, smaller prompts.
- Problem: Forgetting Key Details
- Fix: Review your prompt—does the LLM have all the info it needs? Add necessary context.
How Do You Know If It's Working? Measuring Succes
How can you tell if your prompt is good? Ask yourself:
- Is it Relevant? Does the answer actually address my prompt?
- Is it accurate? Is the information correct (especially important for factual tasks)?
- Is it complete? Does it cover everything I asked for?
- Is it clear? Is the answer easy to understand? Grammatically correct?
- Is it consistent? Does the prompt give similar good results if used again?
- Does it match the tone/style? If you asked for a specific style, did you get it?
The best way to evaluate is often simple: Does the output meet your needs? You can also compare outputs from different prompt variations (A/B testing) or use evaluation tools if you’re building larger applications.
Helpful Tools for Your Journey
You don’t have to do it all manually! There’s a growing ecosystem of tools:
- Prompt Playgrounds: Platforms like the OpenAI playground let you experiment easily.
- Prompt Management Platforms: Tools like PromptHub, Langfuse, Helicone, and PromptLayer help teams create, manage, test, and version prompts.
- Frameworks / Libraries: Libraries like LangChain, LlamaIndex, and LiteLLM help developers build AI applications, often including prompt management features.
- Educational Resources: Websites like LearnPrompting.org, guides from OpenAI, Google, AWS, and numerous online courses offer deeper dives.
Quick Examples (Cheat Sheet)
Here are simple examples based on the techniques:
- Zero-Shot: Translate “Hello world” to French.
- Few-Shot: Tweet: “Loving this sunny weather!” Sentiment: Positive Tweet: “My flight got canceled, so annoying.” Sentiment: Negative Tweet: “Just finished a good book.” Sentiment: (Let the LLM complete)
- Chain-of-Thought: Q: Sarah has 5 apples. She buys 3 more and gives 2 to Tom. How many apples do she have left? Let’s think step-by-step.
- Instruction: Summarize the following paragraph into a single sentence: [Insert paragraph here]
- Instruction (with Persona & Format): Act as a helpful librarian. List 3 classic science fiction novels suitable for young adults, with a brief description for each. Format as a numbered list.
- RAG (Conceptual): Based on the provided document [Document Text], what were the key findings reported in section 3?
Your Step-by-Step Plan for Pragmatic Prompting
Ready to try? Here’s a practical process:
- Define Your Goal: What exactly do you need the LLM to do? Who is the output for?
- Pick Your Technique: Choose the best method (Zero-shot, Few-shot, CoT, etc.) for your task’s complexity. Start simple!
- Write Your First Prompt: Be clear and specific, and provide context. Remember the basics!
- Test and See: Run the prompt and look at the output.
- Evaluate: Does the output meet your goal? Is it accurate, relevant, and precise?
- Refine and Repeat: If needed, tweak your prompt. Add detail, change wording, and try a different technique. Repeat steps 4-6 until you’re happy.
- Use Tools (Optional): If you’re doing this often, explore tools to help manage and test prompts.
- Keep Learning: Pay attention to what works and what doesn’t.
A Note on Ethical Considerations
As you become proficient in prompt engineering, remember to use these skills responsibly. Be mindful of the potential for LLMs to generate biased, inaccurate, or harmful content. Craft prompts that encourage fairness and avoid generating misinformation. Always critically evaluate the output, especially for sensitive applications.
Conclusion: Keep Experimenting!
Prompt engineering isn’t magic; it’s a practical skill you build through practice. By focusing on clarity, providing context, choosing the right techniques, and, most importantly, being willing to experiment and refine, you can unlock the full potential of large language models.
Don’t be afraid to try different approaches. The key is continuous learning and improvement. Start simple, test your prompts, learn from the results, and you’ll quickly become much better at guiding AI to generate the amazing outputs you need. Happy prompting!
