Prompt Engineering Techniques

Prompt engineering is the practice of iteratively refining your inputs to steer Large Language Models toward generating responses that are actually useful, properly structured, and relevant to what you asked.

That's it. It's not magic. It's just being precise.

Using the right prompt engineering techniques is crucial because a great prompt acts like a precision tool, directly translating a vague idea into the exact, high-quality output you need. Ultimately, better techniques mean far less time spent cleaning up or re-running prompts, leading directly to more reliable and efficient results every time.

LLMs are probabilistic engines. They predict what comes next based on patterns. Without structure in your prompt, the model might wander off down a "statistically likely" path that has absolutely nothing to do with what you needed.

Effective prompt design acts as a guardrail — narrowing the model's focus to the specific data and logic required for your task. Think of it as giving directions to someone who knows every road in the country but has no idea where you want to go.

For an AI assistant to be useful in any serious setting, it must produce reliable results. Good prompt engineering allows you to:

• Reduce Hallucinations — By grounding the model in specific context, you discourage it from confidently inventing things that sound plausible but are entirely fictional.
• Control Tone and Voice — Ensuring outputs match your requirements, whether that's formal business prose or something that doesn't read like it was written by a committee.
• Format for Automation — Generating outputs in JSON, Markdown, or other structured formats that integrate seamlessly with downstream systems.

Every expert-level prompt rests on four elements. Miss one, and you're essentially hoping for the best.

• Clear Instruction (The Directive) — The specific task. "Summarize," "Analyze," "Compare." Not "Do something with this."
• Contextual Data (The Grounding) — The background information the model needs. It cannot read your mind, your files, or your company's Confluence pages unless you provide them. (Sharing your company's Confluence pages with an LLM might win you a conversation with your company’s security team, so never give a model more information that you are comfortable with it sharing)
• Persona (The Role Assignment) — The "expert lens" the AI should adopt. More on this shortly.
• Desired Format (The Structure) — What the output should look like. A table? Bullet points? JSON? A haiku? (Please don't request haikus for business reports.)

These techniques rely on In-Context Learning — the model figures out what you want based on what you provide in the prompt itself.

• Zero-Shot Prompting — Giving a task with no examples. Works for simple, unambiguous requests. Falls apart the moment nuance is required.
• One-Shot Prompting — Providing a single example to clarify tone or format. Surprisingly effective for establishing expectations.
• Few-Shot Prompting — Providing 3–5 demonstrations. This is where things get genuinely useful, particularly for complex formatting or niche business logic that the model couldn't possibly guess.

The pattern here is not subtle: more examples, better results. The model learns from what you show it, not from what you assume it knows.

Assigning a persona tells the model which region of its training data to prioritize. This is not theater; it genuinely changes the output.

Instead of asking for "marketing advice," try:

"Act as a senior growth marketer with 20 years of experience in SaaS. Explain the benefits of Permission Set Groups to a business user using an analogy involving a physical office building."

The model doesn't become that person, obviously. But it does shift its probability distributions toward the kind of language, structure, and assumptions that person would likely use. It's the difference between asking "someone" for directions and asking a local cab driver.

CoT encourages the model to show its working. You trigger it by adding something like: "Let's think step by step."

This is essential for any task involving logic, mathematics, or multi-step reasoning — areas where LLMs have a tendency to take confident shortcuts that lead directly off a cliff.

By forcing the model to articulate intermediate steps, you prevent the "leaps of logic" that produce answers which are wrong but sound extremely convincing. It's the AI equivalent of making a student write out their working instead of just circling an answer.

This is a voting mechanism for AI outputs.

You ask the model to generate multiple reasoning paths for the same problem. The answer that appears most frequently is selected as the "consistent" answer.

Why bother? Because even with chain-of-thought prompting, models occasionally get lucky with wrong answers or make one-off logic errors. Self-consistency catches these by essentially running the calculation multiple times and checking whether the results agree.

Particularly valuable for complex calculations where you'd rather not discover the error after you've built a strategy around it.

Where Chain-of-Thought is a single path through a problem, Tree-of-Thought explores multiple branches simultaneously.

The Logic: The model generates several potential solutions, evaluates each one's viability, and then "prunes" the failing branches to reach the best conclusion.

Use Case: Complex strategic planning or creative brainstorming where multiple variables interact and there isn't an obvious single path forward.

Think of it as the difference between walking a maze and having a bird's-eye view of the entire thing. More computationally expensive, but considerably more powerful for genuinely complex problems.

ReAct combines internal reasoning with external tool usage. It follows a loop:

Thought → Action → Observation → Repeat

Here's a more realistic example — the kind of thing that actually demonstrates why this matters:

User: Should I sell my Tesla stock today?

Thought: I need current information to answer this responsibly. Let me check the current stock price, recent news, and analyst sentiment.

Action: Search[TSLA stock price today]

Observation: TSLA is trading at $248.50, down 3.2% today.

Thought: That's a notable drop. I should find out why before making any recommendation.

Action: Search[Tesla stock news December 2025]

Observation: Headlines indicate concerns about Q4 delivery numbers and increased competition from Chinese EV manufacturers.

Thought: Context matters here. What's the user's situation? I should also check analyst consensus.

Action: Search[TSLA analyst ratings consensus]

Observation: Current consensus: 12 buy, 18 hold, 7 sell. Average price target $285.

Final Answer: Tesla is down 3.2% today on delivery concerns, currently trading below the average analyst target of $285. Whether to sell depends on your time horizon and cost basis — a single bad day isn't necessarily a reason to sell, but the competitive pressure narrative is worth monitoring. I can't tell you what to do, but those are the facts you'd want to consider.

The key insight: without ReAct, the model would either refuse to answer (no real-time data) or hallucinate numbers that sound plausible but are entirely fictional. ReAct lets it actually do something useful — gather current information, reason about what else it needs, and synthesize a response grounded in reality rather than statistical probability.

This is the foundation for agentic systems — AI that can take actions in the world rather than simply generating text about potential actions.

One of the most important and most overlooked practices: using the correct syntax for your specific model.

OpenAI (GPT-4o): Prefers Markdown and triple quotes (""") to separate instructions from data.

Anthropic (Claude): Has historically preferred XML tags (e.g., data) to maintain structure and prevent prompt injection. However — and this is worth noting — Anthropic's latest guidance acknowledges that modern Claude models are now better at understanding structure without XML tags, though they can still be useful for complex scenarios.

This isn't aesthetic preference. Using the right structural conventions for your model meaningfully improves instruction adherence. It's like speaking with proper grammar — you'll probably be understood either way, but clarity helps.

A note on the pace of change: the fact that "use XML tags for Claude" went from best practice to "helpful but less critical" within a single model generation tells you something about how quickly this field is moving. By the time you've memorized a technique, the models may have evolved past needing it. Stay curious, keep testing, and hold your best practices lightly.

RAG bridges the gap between a model's static training data and your live information.

By providing the model with external, real-time context — a PDF, a database query, your company's documentation — you eliminate the "knowledge cutoff" problem and dramatically reduce factual errors.

The model doesn't know your Q3 sales figures. But if you give it your Q3 sales figures within the prompt, it can work with them as if it did. RAG formalises this process at scale.

The trajectory here is clear: we're moving from single-turn prompts to autonomous multi-step systems.

Modern agent frameworks use reasoning engines to transform high-level instructions into chains of actions — often integrated via platforms that don't require you to write code for every step.

The prompting techniques above remain foundational. But increasingly, they're components within larger systems rather than standalone interactions.

Wei, J., et al. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models.

Yao, S., et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models.

Yao, S., et al. (2023). Tree of Thoughts: Deliberate Problem Solving with Large Language Models.