Improving Prompts for Large Language Models

Prompt engineering is the new consulting superpower. Most haven't realized it yet. Over the last couple of days, I reviewed the latest guides by Google, Anthropic and OpenAI. Some of the key recommendations to improve output: → Being very specific about expertise levels requested → Using structured instructions or meta prompts → Explicitly referencing project documents in the prompt → Asking the model to "think step by step" Based on the guides, here are four ways to immediately level up your prompting skill set as a consultant: 1. Define the expert persona precisely "You're a specialist with 15 years in retail supply chain optimization who has worked with Target and Walmart." Why it matters: The model draws from deeper technical patterns, not just general concepts. 2. Structure the deliverable explicitly "Provide 3 key insights, their implications and then support each with data-driven evidence." Why it matters: This gives me structured material that needs minimal editing. 3. Set distinctive success parameters "Focus on operational inefficiencies that competitors typically overlook." Why it matters: You push the model beyond obvious answers to genuine competitive insights. 4. Establish the decision context "This is for a CEO with a risk-averse investor applying pressure to improve their gross margins." Why it matters: The recommendations align with stakeholder realities and urgency. The above were the main takeaways I took from the guides which I found helpful. When you run these prompts versus generic statements, you will see a massive difference in quality and relevance. Bonus tips which are working for me: → Create prompt templates using the four elements → Test different expert personas against the same problem (I regularly use "Senior McKinsey partner" to counter my position detecting gaps in my thinking.) → Ask the model to identify contradictions or gaps in the data before finalizing any recommendations. We’re only scratching the surface of what these “intelligence partners” can offer. Getting better at prompting may be one of the most asymmetric skill opportunities all of us have today. Share your favourite prompting tip below! P.S Was this post helpful? Should I share one post per week on how I’m improving my AI-related skills?

In just a few minutes, here’s one thing you can do to make AI outputs 10x sharper. One of the most common reasons that prompts fail is not because they are too long, but because they lack personal context. And the fastest fix is to dictate your context. Speak for five to ten minutes about the problem, your audience, and the outcome you want, then paste the transcript into your prompt. Next, add your intent and your boundaries in plain language. For example: “I want to advocate for personal healthcare. Keep the tone empowering, not invasive. Do not encourage oversharing. Help people feel supported in the doctor’s office without implying that all responsibility sits on them.” Lastly, tell the model exactly what to produce. You might say: “Draft the first 400 words, include a clear call to action, and give me three title options.” Here’s a mini template: → State who you are and who this is for → Describe your stance and what to emphasize → Add guardrails for tone, privacy, and any “don’ts” → Set constraints like length, format, and voice → Specify the deliverable you want next Until AI memory reliably holds your details, you are responsible for supplying them. Feed the model your story - no need to include PII - to turn generic responses into work that sounds like you.

Prompt formatting can have a dramatic impact on LLM performance, but it varies substantially across models. Some pragmatic findings from a recent research paper: 💡 Prompt Format Significantly Affects LLM Performance. Different prompt formats (plain text, Markdown, YAML, JSON) can result in performance variations of up to 40%, depending on the task and model. For instance, GPT-3.5-turbo showed a dramatic performance shift between Markdown and JSON in code translation tasks, while GPT-4 exhibited greater stability. This indicates the importance of testing and optimizing prompts for specific tasks and models. 🛠️ Tailor Formats to Task and Model. Prompt formats like JSON, Markdown, YAML, and plain text yield different performance outcomes across tasks. For instance, GPT-3.5-turbo performed 40% better in JSON for code tasks, while GPT-4 preferred Markdown for reasoning tasks. Test multiple formats early in your process to identify which structure maximizes results for your specific task and model. 📋 Keep Instructions and Context Explicit. Include clear task instructions, persona descriptions, and examples in your prompts. For example, specifying roles (“You are a Python coder”) and output style (“Respond in JSON”) improves model understanding. Consistency in how you frame the task across different formats minimizes confusion and enhances reliability. 📊 Choose Format Based on Data Complexity. For simple tasks, plain text or Markdown often suffices. For structured outputs like programming or translations, formats such as JSON or YAML may perform better. Align the prompt format with the complexity of the expected response to leverage the model’s capabilities fully. 🔄 Iterate and Validate Performance. Run tests with variations in prompt structure to measure impact. Tools like Coefficient of Mean Deviation (CMD) or Intersection-over-Union (IoU) can help quantify performance differences. Start with benchmarks like MMLU or HumanEval to validate consistency and accuracy before deploying at scale. 🚀 Leverage Larger Models for Stability. If working with sensitive tasks requiring consistent outputs, opt for larger models like GPT-4, which show better robustness to format changes. For instance, GPT-4 maintained higher performance consistency across benchmarks compared to GPT-3.5. Link to paper in comments.

You're prompting ChatGPT wrong. Most people think prompting is easy. You just type what you want and hope the model figures it out. But the truth is...prompting is more like coding. There are rules, patterns, and principles that make your results dramatically better. I’ve tested hundreds of prompts across ChatGPT, Claude, Gemini, and small language models. And I’ve learned this the hard way: 🧠 A bad prompt = garbage output 🧠 A good prompt = decent result 🧠 A great prompt = feels like magic Here’s the difference between the three: 👇 📌 26 Prompt Principles You Can Actually Use (𝘈𝘒𝘈: 𝘔𝘺 𝘪𝘯𝘵𝘦𝘳𝘯𝘢𝘭 𝘤𝘩𝘦𝘤𝘬𝘭𝘪𝘴𝘵 𝘸𝘩𝘦𝘯 𝘣𝘶𝘪𝘭𝘥𝘪𝘯𝘨 𝘈𝘐 𝘢𝘨𝘦𝘯𝘵𝘴, 𝘚𝘖𝘗𝘴, 𝘰𝘳 𝘳𝘦𝘶𝘴𝘢𝘣𝘭𝘦 𝘵𝘦𝘮𝘱𝘭𝘢𝘵𝘦𝘴) Some of my favorites: ✅ #3 Break it down Don’t ask a model to write a whole marketing plan in one go. Split it into: research → tone → structure → CTA → final draft. This one shift alone improved my outputs by 70%. ✅ #5 Ask for clarity If you don’t fully understand something, the model won’t either. Try these: • Explain it to me like I’m 11 • Write it in simple terms • Teach me like I’m a beginner in [finance/biology/design] Works beautifully when researching new topics or creating explainers. ✅ #7 Example-Driven Prompting Few-shot prompting is underrated. Want better output? Show the model what “good” looks like first. ✅ #9 and #10: Clear instructions with power words Use language like: “You MUST include…” or “You will be penalized if…” LLMs respond well to assertive structure (not vague human politeness). ✅ #17 Use delimiters Structure matters more than people think. Use triple quotes ("""), sections (## Question, ## Answer), or bullet point layouts to guide the model’s flow. ✅ #22 Clean up user writing without changing voice One of my favorite Claude tricks: "Revise this to improve grammar and flow, but don’t change the style or voice." Feels like a human editor. ✅ #24–26 Advanced use cases Prompt continuation, completing documents, and role-based generation. These come in handy when you’re building internal workflows or chaining prompts via API. If you're serious about AI.....whether you’re building a product, training teams, or writing daily content, these 26 principles are your foundation. They’ll help you: → Avoid vague outputs → Save hours of editing → Train better agent loops → Scale LLMs across your org I’ve attached the full table as an image, worth bookmarking. And if you want this in a PDF..just comment "PDF", I’ll share it. You don’t need to use all of them. But if you’re stuck, use this as a toolkit to debug and refine. 📌 Save this for future reference, it will help you go from average to expert in prompt design. ♻️ Share this post and help someone who needs this in their workflow! Subscribe to level up with AI everyday: https://shrutimishra.co 💡 Follow Shruti Mishra for more tips on leveraging AI for career success!

Monday Technical Deep Dive: Prompting for Precision You've probably heard about AI everywhere, but are you prompting it right to get the best results? Getting useful output from models like Gemini or ChatGPT isn't magic; it's a skill called Prompt Engineering. If your prompt is weak, your output will be too. I recently attended Google’s Generative AI Leader Program and solidified a core principle: Better Inputs = Better Outputs. Here are three simple techniques to immediately improve your results: 1. Zero-Shot Prompting (The Baseline) This is the simplest approach. You give the model no examples, just the instruction. Example: "Explain the concept of API idempotency." When to use it: For basic questions, definitions, or tasks where the model already has extensive knowledge. It's your starting point. 2. Few-Shot Prompting (The Teacher) This is where you give the model a few examples of the desired input/output format before asking your actual question. You are essentially teaching it your style. Example: "Here are three examples of how I write a professional email closing: [Example 1], [Example 2], [Example 3]. Now, write an email to a recruiter following this style." When to use it: When the output needs to match a specific format, tone, or structure (e.g., code functions, marketing copy, or technical documentation). 3. Chain-of-Thought (CoT) Prompting (The Analyst) This is the most powerful technique for complex tasks. You instruct the model to explain its reasoning step-by-step before providing the final answer. Example: "Before giving the final answer, first list and explain the security risks associated with deploying this new cloud function. Then, suggest three mitigation strategies." When to use it: For complex analysis, multi-step problem-solving, or debugging. For me, this is essential when working on AI and Security concepts, as you need verifiable reasoning. Prompting is a skill that will only grow in importance. Which of these techniques are you going to test today? Let me know your results! #GenerativeAI #PromptEngineering #TechnicalDeepDive #SoftwareEngineering #AI

Anthropic’s “Prompting 101” is one of the best real world tutorials I’ve seen lately on how to actually build a great prompt. Not a toy example. They showcase a real task: analyzing handwritten Swedish car accident forms. Here’s the breakdown: 1. Stop treating prompts like playground experiments > Prompting is iterative engineering, not creative writing > Test, observe, refine - just like product development > One-shot prompts are amateur hour nonsense 2. Structure isn't optional - it's everything > Task context prevents dangerous model hallucinations > Static knowledge belongs in system prompts > Step-by-step instructions eliminate unpredictable outputs 3. Your model will lie without constraints > Claude hallucinated skiing accidents from car forms > Context and rules are your only defense > Trust but verify is dead - verify first 4. Examples are your secret weapon > Few-shot learning steers model behavior precisely > XML tags create structured reasoning pathways > Concrete examples beat abstract instructions always 5. Order of operations determines success > Analyze forms before sketches - sequence matters > Human reasoning patterns should guide model flow > Random instruction order produces random results 6. Output formatting is non-negotiable > Structured JSON/XML enables downstream processing > Parsing requirements must be baked in > Pretty responses don't integrate with databases 7. System prompts are your knowledge base > Static information belongs in system context > Prompt caching makes this economically viable > Domain expertise must be explicitly encoded 8. Extended thinking reveals model reasoning > Thinking tags expose decision-making processes > Analyze transcripts to improve prompt engineering > Model introspection beats guessing every time 9. The prompt IS the program > Language interfaces replace traditional APIs completely > Production teams version control their prompts > Treat prompts like mission-critical infrastructure code 10. Most "AI failures" are prompt failures > Garbage prompts produce garbage AI agents > Proper prompt engineering eliminates 80% of issues > Your AI is only as good as your instructions Link to the tutorial is in comments.

Most people are using GenAI wrong. They ask one-shot questions and expect magic. If you want real results, that are more relevant, thoughtful, and useful, then you need to prompt better. Here are two advanced prompting patterns that dramatically improve output from any major GenAI chatbot (ChatGPT, Claude, Gemini, Copilot, etc.). These patterns work across them all. CHAIN-OF-THOUGHT PATTERN - Get the model to “think out loud” by breaking down its reasoning into clear, logical steps before giving an answer. Use cases: math, logic, pricing, diagnostics, and planning. Steps: * Use cues like “Let’s work this out step by step." * Optionally include an example (few-shot) or let it figure it out (zero-shot). ✔️ Pros: Improves accuracy and transparency. ❌ Cons: Slower, and if the first step is wrong, the rest often is. TREE-OF-THOUGHT PATTERN - Structure your prompt so the model explores multiple paths or ideas, then compares and converges on the best option. Use cases: root cause analysis, strategic decisions, and product ideas. Steps: * Ask it to explore different possibilities. * Have it compare them. * Ask for a final recommendation. ✔️ Pros: Encourages critical thinking and creativity. ❌ Cons: Verbose, computationally heavy, may overthink. Most people stop at the first answer. These techniques push the model to do more: to reason, refine, and iterate. Prompt smarter. Get better results. #PromptEngineering #GenerativeAI #ChatGPT #AIProductivity #WorkSmarter #AdvancedPrompts #AIChatbots #LLMs #AIForWork

Prompt optimization is becoming foundational for anyone building reliable AI agents Hardcoding prompts and hoping for the best doesn’t scale. To get consistent outputs from LLMs, prompts need to be tested, evaluated, and improved—just like any other component of your system This visual breakdown covers four practical techniques to help you do just that: 🔹 Few Shot Prompting Labeled examples embedded directly in the prompt help models generalize—especially for edge cases. It's a fast way to guide outputs without fine-tuning 🔹 Meta Prompting Prompt the model to improve or rewrite prompts. This self-reflective approach often leads to more robust instructions, especially in chained or agent-based setups 🔹 Gradient Prompt Optimization Embed prompt variants, calculate loss against expected responses, and backpropagate to refine the prompt. A data-driven way to optimize performance at scale 🔹 Prompt Optimization Libraries Tools like DSPy, AutoPrompt, PEFT, and PromptWizard automate parts of the loop—from bootstrapping to eval-based refinement Prompts should evolve alongside your agents. These techniques help you build feedback loops that scale, adapt, and close the gap between intention and output

Here's a practical hack for improving your prompt engineering skills: Prompting is messy at first. Often, you start with something vague, then continuously refine it, correcting the model, adding context mid-conversation, and clarifying your intent until you finally get the output you're looking for. But there's a step most people skip: Once the model finally gets to the desired output, ask it: “Based on everything we've worked through in this conversation, what's the best prompt I could have given you upfront to reach this result immediately?” Then test this refined prompt in a fresh chat. It might not be perfect yet, but it typically gets you much closer. Repeat this feedback loop until your refined prompt reliably produces the output each time. I used this process extensively while preparing live trainings for the Australian Water School, where multiple participants had to follow along with me and we all needed to arrive at a very similar output. It's also how I refined prompts for examples in my "ChatGPT for Water Resources Engineers" course. Ultimately, this approach pays off most when you're building reusable prompts or instructions for custom GPTs. You will need to embrace the iterative nature of working with AI. Provide feedback and additional context, working collaboratively with AI rather than just treating it as a tool. After doing this several times, you will have a better understanding of the information required by the LLM and your initial prompts will get much better, and the need for iteration will decrease.

Simple prompt hack that doubled the quality of my LLM outputs. I've been testing AI tools nonstop for months. Most people focus on better models or fancier features. But the biggest improvement came from adding six words to every prompt: "Before answering, ask any clarifying questions." That's it. Why this works: LLMs are terrible at reading your mind. They'll make assumptions about scope, audience, format, constraints - usually wrong ones. By forcing them to ask questions first, you get responses that actually match what you need. Real example: Old prompt: "Write a product roadmap for our AI agent platform" New prompt: "Write a product roadmap for our AI agent platform. Before answering, ask any clarifying questions." The LLM now asks about timeline, audience, level of detail, key features to prioritize. The final output is 10x more useful. Works everywhere: Cursor asks about coding patterns and architecture choices Lovable asks about UI requirements and user flows Claude asks about tone and target audience for writing Any chat interface gets more specific before diving in Most of us rush into prompts like we're texting a friend. But LLMs aren't mind readers. They have limited context and will fill gaps with generic assumptions. Making the clarification step explicit forces better communication upfront. Bottom line: The best AI responses come from better questions, not better models. Try it on your next prompt. You'll be amazed how much clearer the output becomes when the AI actually understands what you're asking for. What prompt tricks have changed your AI workflow? Always looking for new ways to get better signal from these tools.