Mark Jakubowicz
Back to blog
•
12 min read
AI Prompt Engineering

🧭 Introduction

Prompt engineering is at the heart of how we interact with modern LLMs. Whether you’re asking a question, building chatbot, automating workflows, or querying a language model for insights, the way you phrase your instructions—your prompt—can dramatically affect the results. This post explores what prompt engineering is, why it matters, and how to do it effectively using real-world examples and frameworks.

📚 Quick Navigation

🧠 What Is a Large Language Model (LLM)?

A Large Language Model (LLM) is a foundational AI system trained on massive corpora of text data. Its core function is predicting the next token—that is, determining the most likely next word (or part of a word) in a sequence given the context of preceding text.

These models are built using deep learning architectures (most notably transformers), and learn complex statistical patterns from billions of sentences across books, websites, code, and other written sources.

Popular examples include:

  • GPT-4 (OpenAI)
  • Claude (Anthropic)
  • Gemini (Google DeepMind)
  • LLaMA (Meta)
  • Mistral (Mistral AI)

LLMs are stateless by default, meaning they do not remember past conversations or inputs between calls unless external memory is explicitly integrated. Each prompt is treated independently, and context must be re-supplied if continuity is required. This design makes LLMs reliable for single-turn tasks, but limits their use in longer workflows without added layers like agents or memory buffers.

Despite this, their ability to generalize across domains, synthesize knowledge, and generate fluent, structured output makes them one of the most transformative tools in modern AI.

🤖 What Is an AI Agent?

An AI agent is a goal-driven system built on top of a large language model (LLM), designed to extend its capabilities with memory, tool usage, and autonomous behavior. While LLMs are powerful, they respond only to the current input and have no inherent memory or ability to act independently.

Agents build on this foundation by adding:

  • Memory – They track previous interactions and can recall relevant information across sessions.
  • Tool Use – Agents can interact with external tools such as APIs, calculators, file parsers, and search engines.
  • Goal Orientation – Rather than single-turn responses, agents can pursue complex objectives like “research a topic and generate a report.”
  • Autonomous Decision-Making – Agents can determine next steps without user intervention, chaining prompts or tool calls as needed.

This makes AI agents especially valuable in scenarios like customer support, research assistants, and workflow automation, where multi-step reasoning, persistence, and proactivity are critical.

✍️ How to Write Effective Prompts

In order to leverage the full potential of large language models, it’s essential to understand how to construct prompts that are not only clear and specific, but also contextually rich and iterative. A well-written prompt can mean the difference between a vague, unusable output and a precise, production-ready response.

One of the most effective prompt design tools is the T.C.R.E.I. model. This five-step framework helps you build structured prompts that yield reliable, repeatable results:

  1. Task – Begin by stating what you want the model to do, as clearly and unambiguously as possible. Instead of saying “Write something about LLMs,” you could say, “Write a 300-word explainer on how large language models process natural language.”

  2. Context – Add relevant background information the model needs to understand the situation. This might include the audience, tone, format, or constraints. For instance, “The article is for a beginner-friendly tech blog aimed at non-programmers.”

  3. References – Provide concrete examples or templates the model can emulate. This could be snippets of a preferred writing style, sample outputs, or even a bulleted list of facts to include. References reduce ambiguity and improve alignment with your goals.

  4. Evaluate – Review the output and ask: Does it meet the task requirements? Is the tone right? Are important details missing? Evaluation helps you pinpoint where the model may need nudging or refinement.

  5. Iterate – Prompting is rarely a one-shot success. Based on your evaluation, adjust your prompt. Add more context, reframe the task, supply a better reference, or clarify formatting. This continuous improvement loop is essential for achieving high-quality results.

Whether you’re just asking a question, scripting internal automations, or generating code documentation, applying this structured method will improve consistency, reliability, and creative control over how LLMs respond.

🧪 Prompt Example: Applying the T.C.R.E.I. Method

To illustrate how the T.C.R.E.I. framework works in practice, here’s a prompt crafted with each of its five components in mind:

You are a technical content writer contributing to a beginner-friendly AI blog.
Write a 300-word explainer on how large language models (LLMs) work.
Explain the concept of token prediction and provide a high-level description of transformer architecture.
Use an accessible tone suitable for non-programmers.
Reference the explanation style from the 'Explain Like I'm Five' subreddit.
The structure should include a heading, a brief intro, and two short paragraphs.

This prompt is effective because it:

  • Task – Clearly asks for a 300-word explainer on LLMs
  • Context – Specifies the tone, format, and audience (non-programmers)
  • References – Cites a stylistic reference (“Explain Like I’m Five” subreddit)
  • Evaluate – Can easily be reviewed against the required format, tone, and clarity
  • Iterate – Is designed to be refined (e.g., by adjusting length or complexity if needed)

🟢 Four Prompt Iteration Techniques

If the initial output isn’t quite right, you can improve it using these strategies:

  1. Revisit the Framework – Check if the prompt fully specifies the task, context, and desired tone. Add missing elements like examples or audience info.
  2. Simplify the Prompt – Break long instructions into shorter sentences to reduce ambiguity and help the model follow your intent more easily.
  3. Rephrase or Analogize – Reformulate the prompt or shift to a related task to guide the model indirectly. For example, instead of “write an email,” try “explain this schedule change like you would to a colleague.”
  4. Add Constraints – Limit the scope by setting parameters: word count, style (“bullet points only”), or perspective (“from a supervisor’s point of view”).

This will not always provide the result you expected at first, so ensure that you remember to iterate on the process.

🔄 Meta-Prompting

The next level of iteration is to ask the model to help you improve your prompt. This technique, called meta-prompting, treats the model not just as a generator of output, but as a collaborator in the design process.

You are an expert prompt engineer. Review the following prompt for:
- Ambiguity or unclear instructions
- Format or structural issues
- Missing edge cases or assumptions

Then, rewrite it for clarity and reliability.

Prompt:
[INSERT YOUR PROMPT HERE]

An advanced strategy is to perform cross-model meta-prompting, where one model (e.g., GPT-4) evaluates and optimizes prompts that will later be run on a different model (e.g., Mistral or Claude). This is particularly useful when using high-performance, expensive models to tune prompts for lower-cost, faster ones.

Use Case Example:

  • Use GPT-4 to rewrite and evaluate prompts intended for a voice assistant running on a smaller, latency-optimized model like Mistral.
  • Ask GPT-4 to enforce output structures that the target model must follow strictly, such as JSON or XML schemas.
  • Validate prompt phrasing to ensure it avoids known weaknesses in the smaller model (e.g., hallucinations, incomplete responses).

This strategy allows you to leverage the reasoning capacity of a more capable model to design robust, portable prompts for constrained environments—enabling prompt portability and consistent performance across a fleet of agents.

🖼️ Multimodal Prompting

Modern large language models like Gemini, GPT-4 with vision, and Claude 3 can handle multimodal inputs—accepting not only text, but also images, audio, and code snippets as part of a prompt. This allows them to reason over diverse data types and produce more flexible outputs.

To get the most out of multimodal prompting:

  • Be explicit about the input – Describe what the model is receiving. For example: “Analyze this image of a marketing flyer for design suggestions.”

  • Specify the expected output format – Whether it’s a bulleted list, HTML layout, or JSON object, giving formatting guidance improves consistency.

  • Maintain prompt structure – Use headings, short instructions, and delimiters (e.g., image or code) to help the model distinguish between modalities.

  • Example Use Cases:

    • Image input + text output: “Describe the visual style and emotional tone of this artwork.”
    • Audio input + transcript: “Summarize the main points of this meeting recording.”
    • Mixed input: “Given the image of the whiteboard and the attached bullet points, generate a project proposal draft.”

Multimodal prompting opens up new possibilities in areas like design critique, accessibility tools, real-time transcription analysis, and more. It does, however, require extra clarity in prompt structure since models must interpret and align between different modalities.

🧹 Advanced Prompting Techniques

🔗 Prompt Chaining

Prompt chaining involves structuring a series of prompts where the output of one becomes the input of the next. This allows you to break down complex workflows into manageable steps. For example:

  1. First prompt: “Summarize the key findings of this research paper.”
  2. Second prompt: “Now take that summary and turn it into a 5-slide presentation outline.”

This technique is powerful for building agents or automation pipelines, and helps maintain clarity across multistep reasoning processes.

🧠 Chain of Thought Prompting

Chain of Thought (CoT) prompting encourages the model to reason step-by-step. Instead of jumping directly to a conclusion, the model explains its intermediate logic.

Solve the math problem and explain your reasoning step-by-step.

This improves accuracy on tasks involving logic, math, or decision-making by having the model outline its thinking process.

🌳 Tree of Thought Prompting

Tree of Thought (ToT) prompting builds on CoT by having the model explore multiple reasoning paths. It creates a branching structure—like a decision tree—so the model can evaluate different options before committing to a conclusion.

Explore at least three different ways to solve this problem. For each, explain the pros and cons. Then choose the most effective approach and justify your choice.

This is useful for creative problem-solving, strategic planning, or any task where diverse perspectives and decision trade-offs matter.

🛠️ Designing AI Agents

Designing AI agents means building intelligent systems that operate over time, use tools, remember prior steps, and act with purpose. A well-designed agent setup includes:

  1. Define Persona – Who is the AI pretending to be? This sets tone, behavior, and expectations. Example: “You are a compassionate virtual therapist.”
  2. Provide Context – Include task background and constraints. Example: “The user is practicing mock interviews for a software engineering role.”
  3. Set Conversation Structure – Establish rules for turn-taking or output style. Example: “Ask one question at a time. Wait for the user’s response.”
  4. Stop Phrase – Use a phrase to gracefully end the session. Example: “Type ‘Jazz hands’ to exit roleplay.”
  5. Feedback Summary – Request a final summary or reflection. Example: “After the session, provide constructive feedback on performance.”

🧪 Agent Roleplay Example

You are a career development trainer simulating a final-round interview.
Help interns practice articulating their strengths and discussing career goals.
Once the intern types "jazz hands", end the roleplay and give constructive feedback.

This structure supports reusable, interactive agents that feel more coherent and helpful across multi-turn conversations.

🦾 Final Thoughts

Prompt engineering is part art, part science—and increasingly, part infrastructure. As large language models grow more capable and agents more autonomous, the quality and structure of your prompts become a critical part of system design. A vague or inconsistent prompt can lead to erratic behavior, while a well-crafted one can unlock reliable, intelligent output across diverse contexts.

Treat your prompts like production code:

  • Modular – Break complex interactions into reusable, composable blocks.
  • Testable – Validate prompt behavior across different inputs and edge cases.
  • Versioned – Track iterations over time, especially in team workflows.
  • Documented – Clarify intent for future collaborators or self-reference.

As LLMs become foundational in tools, workflows, and applications, prompting is no longer just a UX pattern—it’s a core interface layer. The more intentional you are with prompt engineering, the more control you’ll have over model behavior, consistency, and performance.

If you’re building applications that use AI agents, make sure they benefit as models improve. Your system should naturally get better as the underlying LLMs advance. If your application doesn’t improve when the models do, it’s likely not leveraging the architecture well—and may not be worth the long-term investment.

📌 References