DEV Community: Novita Guok

From Input to Impact: Driving Results with Prompt Engineering (Part 1: Foundational & Static Patterns)

Novita Guok — Mon, 27 Jul 2026 08:29:15 +0000

Prompt engineering is the art and science of crafting inputs (prompts) to get clear, accurate, and useful responses from artificial intelligence models.

Instead of treating an AI like a standard search engine, prompt engineering treats it like a skilled assistant: the quality of the output directly depends on how you frame the instructions, context, and format.

How Generative AI Work?

A brief answer: probability.

Generative AI is based on mathematical statistical theory. First, a model is trained on a massive dataset. During this process, the model learns the patterns of how data appears and how it correlates with other data within specific contexts.

Through this learning process, the model builds a distributed probability system. When given a prompt, it generates new content by continuously predicting the next most probable output.

Let's see the example below.

A generative AI model processes the whole prompt to understand the correlation between every word. This allows the model to provide a context-relevant response.

What is interesting is that the responses provided are flexible and varied, even with the same model and prompt. This is due to the random seed that is used for randomization when choosing the output.

To learn more about how Generative AI works, you can check out this reference: Transformers (how LLMs work) explained visually.

Challenges

Training Dataset Cut-Off Date

Generative AI models are trained on massive datasets. However, these datasets are static and do not contain real-time updates. For example, OpenAI's GPT-4 has a knowledge cut-off date of October 2023, meaning the model lacks information about events or developments beyond that date.
Bias

A model's output depends directly on the quality and balance of its training data, which is rarely free from bias. For instance, if you ask an AI to compare several products, but the training data contains significantly more positive information about Product A than its competitors, the model's response will likely lean in favor of Product A.
Hallucinations

It is crucial for Generative AI users to understand that models generate responses by predicting the most probable next word, not by retrieving verified facts. This probabilistic nature can lead to "hallucinations"—instances where the model confidently generates incorrect or completely fabricated information.

Best Practises

Role

Define a specific persona or expert role for the AI to adopt. This helps the model tailor its tone, style, and complexity to match the target audience's level of understanding.
Objective

Provide clear, direct instructions or goals. Setting explicit expectations reduces ambiguity and prevents the model from generating overly broad or generic answers.
Context

Supply essential background data or relevant details for the AI to work with. Without sufficient context, the model will make assumptions to "fill in the gaps," which often leads to inaccurate or irrelevant results.
Constraint / Limitation

Establish strict boundaries, such as response length, formatting rules, or topics to avoid. Setting clear limits keeps the model focused only on delivering what you need.

Prompt Engineering Patterns

Pattern: The Persona

Defining Personas Using personas helps the AI model understand context and constraints, ensuring the generated output is more relevant, specific, and tailored to a particular viewpoint. A simple framework for this is the R-I-C formula:

Role: the job or identity (e.g., "Act as a senior software engineer").
Identity: key demographic and background details (e.g., "You have 7 years of experience writing in Kotlin and love teaching beginners").
Communication style: the tone, formatting, and behavior (e.g., "Keep explanations simple, encouraging, and end with a brief question").

Example Formulas

The Expert/Professional Pattern

"Act as a [Profession] specializing in [Specialty]. You have [Number] years of experience. Please answer my questions using [Tone/Style, e.g., clear, concise, professional English]."
The Fictional/Creative Pattern

"You are [Character Name/Description] from [Context/Setting]. Your personality is [Traits]. When you speak, use the vocabulary and voice of [Character/Archetype]."

Pattern: The Audience/Reverse Persona

By specifying the target audience, the AI model adjusts its tone, terminology, and detail level to match the user's specific background and depth of knowledge.

Example Formula

"Explain [Topic] to me as if I am [Audience Profile, e.g., a five-year-old child / an anxious first-time buyer]. Use simple terms and avoid complex jargon."

Pattern: Few-Shot

In simple terms, this pattern provides several input-output examples (shots). It is exceptionally helpful for tasks requiring a specific output format, such as information extraction or structured content creation.

Example 1 Input: "My internet keeps dropping every five minutes."
Example 1 Output: Category: Technical Issue
Example 2 Input: "Where is the refund status for my last order?"
Example 2 Output: Category: Billing Inquiry
Your Turn Input: "I cannot log into my mobile app account."
Your Turn Output: [Model fills in: Category: Technical Issue]

Or you can show the model the exact structural layout you expect back. E.g.,

Example 1 Input: "Send an email to John Smith at john@example.com about the meeting."
Example 1 Output: {"name": "John Smith", "email": "john@example.com", "topic": "meeting"}
Example 2 Input: "Message support for Sarah Jenkins regarding her subscription at sarah@test.org."
Example 2 Output: {"name": "Sarah Jenkins", "email": "sarah@test.org", "topic": "subscription"}
Your Turn Input: "Reach out to Alex Brown (alex.b@sample.net) to schedule an interview."
Your Turn Output: [Model fills in: {"name": "Alex Brown", "email": "alex.b@sample.net", "topic": "interview"}]

Pattern: Chain-of-Thought

Research shows that Generative AI models are significantly more accurate when guided through a step-by-step reasoning process rather than asked to jump straight to a final answer. We can implement this in two ways:

Instructing the AI directly to show its step-by-step reasoning (e.g., "Think step-by-step before providing the final answer").
Providing worked-out examples that demonstrate the complete reasoning process.

While both patterns guide the AI using examples, Few-Shot and Chain-of-Thought patterns differ in depth and purpose. Few-Shot Prompting simply provides input-output pairs to show the expected final format, helping the AI map a specific input to a desired output structure. On the other hand, Chain-of-Thought Prompting goes a step further by demonstrating the step-by-step reasoning behind an answer, guiding the model on how to solve the problem logically before reaching a conclusion.

Example Prompt:

Q: A local bakery had 40 croissants at 8:00 AM. They sold 25 during the morning rush and baked a fresh batch of 30 at noon. How many croissants are available now?
A: The bakery started with 40 croissants. They sold 25, leaving 40 - 25 = 15. Then they baked 30 more, making 15 + 30 = 45. The answer is 45.

Target Question: A store receives a shipment of 150 phones. They sell 45 on Monday and 30 on Tuesday. On Wednesday, 10 damaged units are returned to stock. How many sellable phones remain?

AI Output:

The store started with an initial inventory of 150 phones.
On Monday, 45 phones were sold: 150 - 45 = 105.
On Tuesday, 30 phones were sold: 105 - 30 = 75.
On Wednesday, 10 returned units were added back to stock: 75 + 10 = 85.
The answer is 85 sellable phones.

Pattern: ReAct

As Generative AI users, we can empower models to utilize external tools when generating responses. ReAct—short for Reasoning and Acting—is an advanced evolution of the Chain-of-Thought pattern. Beyond guiding the model to process tasks step-by-step, ReAct enables the model to take actions—such as querying external APIs or databases—to retrieve real-time information it doesn't natively possess.

The ReAct framework operates through three core components:

Thought: The model formulates a step-by-step plan based on the user's prompt and the context currently available.
Action: The model executes a specific task to gather additional information, such as making an external API call or performing a search.
Observation: The model analyzes the data retrieved from the action and uses it to synthesize the final response.

Example

Question: What is the current market capitalization difference between Apple and Microsoft in USD?

Thought 1: I need to fetch the real-time market cap of Apple (AAPL).
Action 1: Search[Apple AAPL current market capitalization USD]
Observation 1: Apple's market capitalization is approximately $3.45 trillion USD.

Thought 2: I need to fetch the real-time market cap of Microsoft (MSFT).
Action 2: Search[Microsoft MSFT current market capitalization USD]
Observation 2: Microsoft's market capitalization is approximately $3.12 trillion USD.

Thought 3: I need to subtract Microsoft's market cap from Apple's market cap to find the difference.
Action 3: Calculator[3.45 - 3.12]
Observation 3: 0.33

Thought 4: I now have the final calculation in trillions.
Final Answer: The current market capitalization difference between Apple and Microsoft is approximately ($330 billion USD).

The Golden Rule: The clearer your instructions, context, and examples, the less room the AI has to make assumptions or hallucinate.

From Input to Impact: Driving Results with Prompt Engineering (Bonus: Output Consistency Pattern)

Novita Guok — Mon, 27 Jul 2026 08:28:52 +0000

The Result Consistency Pattern (often referred to as the Template or Format Enforcement Pattern) is a prompt engineering design technique used to ensure an AI model returns responses in a uniform, predictable structure every single time, regardless of varying user inputs.

Because Large Language Models (LLMs) are probabilistic and generative by nature, running the same prompt multiple times can produce vastly different layouts, tones, or structures. The Result Consistency Pattern fixes this by removing structural ambiguity.

Why Is It Needed?

In production environments, AI outputs are frequently parsed by code, saved to databases, or fed into downstream software tools. If the output format varies (e.g., returning markdown one time and standard text the next), downstream parsers break.

Pattern: Tail Generation

A technique where key instructions, formatting rules, or operational constraints are appended at the very end of the prompt—after all the background context, examples, or user data.

Because Large Language Models (LLMs) rely on attention mechanisms, they tend to exhibit recency bias (paying stronger attention to tokens at the end of the context window). Placing critical instructions at the "tail" helps prevent the model from drifting, ignoring rules, or adding unwanted conversational padding.

The structure of a standard long Tail Generation Prompt is structured in three layers:

Context / data input: user inputs, database context, long documents
Task requirements & examples: what needs to be done with the data
TAIL INSTRUCTIONS (recency anchor): "REMEMBER: Return ONLY the JSON schema. Start with {"

Examples

Example 1: Preventing Conversational Filler (JSON Extraction)

Without Tail Prompt

System: Extract names and emails into JSON.

User Data: [Insert 2,000 words of email threads...]

AI Output: "Sure! Here is the JSON extracted from your emails: ```

json..." (Breaks code parsers)

With Tail Prompt


plaintext
User Data: [Insert 2,000 words of email threads...]

---
CRITICAL TAIL INSTRUCTION: 
Extract the names and emails from the text above into a valid JSON array.
Do NOT include introductory phrases, explanations, or Markdown code blocks.
Your response MUST begin directly with the character '['.

Example 2: Enforcing Tone and Constraints on Large Datasets


xml
<context>
  [Insert complex financial report here]
</context>

<task>
  Summarize the key revenue risks outlined in the financial report above.
</task>

<tail_instructions>
  CRITICAL CONSTRAINTS:
  - Keep the summary to exactly 3 bullet points.
  - Do not use corporate jargon; explain as if speaking to a high school student.
  - End your response with the phrase: "End of Risk Report."
</tail_instructions>

Last, the here are best practices for Tail Prompting:

Use Visual Separators: Use horizontal lines (---) or XML tags (<tail_instructions>) to clearly decouple the tail instructions from the input data.
Use Imperative Language: Use clear, forceful commands ("Do NOT...", "You MUST begin with...").
Prefix the Output: If the API or platform supports it, pre-filling the model's response start token (e.g., forcing the model's output to start with {) works hand-in-hand with tail generation.

Pattern: Template

In software development, we often require AI model responses to follow a strictly predictable structure—such as valid JSON, CSV, or XML—so downstream application code can parse the output without breaking. The Template Pattern (or Output Consistency Pattern) guarantees structural uniformity across variable inputs. To implement this pattern, we can:

Use labeled delimiters: Enclose your required output schema, rules, and input data using clear delimiters such as XML tags (<schema>...</schema>), square brackets ([...]), or backticks (``). Delimiters cleanly separate instructions from context, making parsing boundaries explicit to the model.
Apply Tail Generation Prompting: Append your formatting rules and start-token constraints at the very end of the prompt (the "tail"). Placing key formatting constraints last leverages recency bias, ensuring the model does not add conversational preambles or postscripts.

Example Prompt Formula


xml
<context>
  Analyze the following customer review: "[Insert Review Text]"
</context>

<output_template>
  Return the analysis strictly using the XML structure below:

  <review_analysis>
    <sentiment>[Positive | Neutral | Negative]</sentiment>
    <category>[Technical | Billing | General]</category>
    <summary>[1-sentence summary]</summary>
  </review_analysis>
</output_template>

<final_rules>
  CRITICAL: Return ONLY the raw XML code above. Do not include markdown block wrappers, introductory greetings, or postscript remarks. Your response MUST begin directly with "<review_analysis>".
</final_rules>

From Input to Impact: Driving Results with Prompt Engineering (Part 2: Adaptive Prompting)

Novita Guok — Mon, 27 Jul 2026 08:07:52 +0000

Also known as Dynamic Prompting is a technique where an AI system adapts its instructions in real time based on user input, task complexity, or feedback.

Instead of relying on a single, fixed text template (a "static prompt"), an adaptive prompting framework acts as a flexible pipeline that builds or alters the prompt on the fly before sending it to the Large Language Model (LLM).

Feature	Static Prompting	Adaptive Prompting
Instruction Structure	Fixed template regardless of input.	Dynamically composed at runtime.
Complexity Handling	Same prompt used for simple and hard tasks.	Escalates detail or reasoning steps for hard tasks.
Context Awareness	Limited to hardcoded rules or fixed examples.	Adjusts persona, tone, or constraints based on user data.
Tool Usage	Fixed tool calls or manual intervention.	Dynamically injects tool definitions only when needed.

How Adaptive Prompting Works

An adaptive prompting pipeline typically follows four core steps:

Input Analysis & Classification: When a user submits a query, an orchestrator (or a lighter classifier model) analyzes the user's intent, sentiment, background, and the task's complexity.
Dynamic Context Assembly: Based on the analysis, the system retrieves only the necessary context (e.g., user preferences, relevant database records, specific few-shot examples) and selects an appropriate persona or operational role.
Instruction Injection: The system constructs the final prompt by stitching together modular rules.

*   *Example:* If the user is identified as a beginner, the system dynamically appends the rule: `"Use simple analogies and avoid jargon."`

*   *Example:* If the user query requires real-time math or web data, the system injects tool-use instructions (such as ReAct steps).

Feedback Loop & Refinement (Self-Correction): If the LLM's output fails a validation check (e.g., bad JSON formatting or hallucinated facts), the system automatically creates a follow-up prompt containing the error message to ask the model to correct itself.

Prompt Engineering Patterns

Pattern: Question Refinement

When posing a question, we often have an incomplete or vague idea of what we actually want to achieve. Because our prompts are constrained by our limited initial knowledge, the AI model may deliver unexpected or unhelpful results due to missing context.

The Question Refinement Pattern solves this by turning the AI into a collaborative editor before it attempts to generate a final answer.

How to implement this pattern?

Ask the AI to generate improved variations: Instruct the model to analyze your original prompt and propose several clearer, more specific, or better-structured alternative questions.
Require confirmation before answering: Direct the model to pause and ask you to select or refine its suggested options before it provides the final answer.

Example Prompt Formula

"Whenever I ask a question about [Topic], suggest 3 better, more specific versions of my question that would yield a more thorough and accurate answer. Then, ask me which version I would like you to answer."

Pattern: Alternative Approaches

The core idea of this pattern is to prompt the AI model to generate multiple pathways or methods to solve a single problem. Rather than settling on the first solution, this approach encourages reflection on your true objectives and allows you to evaluate which method is best suited for your constraints.

Generate multiple solutions: Instruct the AI to list alternative approaches or methods that achieve the same core objective as your initial request.
Compare trade-offs: Ask the AI to compare the pros and cons (or advantages and disadvantages) of your original approach against the alternatives it proposes.

Example Prompt Formula

"I want to achieve [Goal/Task]. Here is my initial idea: '[Insert your approach]'. Before implementing it, please list 3 alternative ways to accomplish the same goal, and compare the pros and cons of each method against my original idea."

Pattern: Cognitive Verifier

Works by having the AI model break down a primary question into smaller, sub-questions ("atomic queries") to collect necessary context and verify details before delivering a final answer. How to implement this pattern:

Instruct the model to ask sub-questions: Require the AI to generate and answer additional sub-questions to gather comprehensive background data before addressing your main query.
Require complete data synthesis: Direct the model to explicitly incorporate the answers from all sub-questions when synthesizing its final response.

Example Prompt Formula

"When I ask you '[Insert your main question]', follow these steps before answering:

Break my query down into 3–4 foundational sub-questions required to answer it accurately.
Answer each sub-question individually.
Combine the insights from all sub-questions to provide a well-verified final response."

Pattern: Flipped Interaction

Imagine you are developing an Android e-Library application and need to write unit tests for the "Add Book" feature. You are unsure how to structure the test code and haven't identified all the necessary edge cases. Because your own requirements are unclear, crafting a precise initial prompt is difficult—and asking a vague question will likely yield an incomplete answer.

The Flipped Interaction Pattern solves this problem by turning the traditional AI dynamic upside down: instead of you asking the AI questions, the AI asks you questions to draw out the necessary details and constraints. Step:

Define the ultimate goal: State your target objective clearly (e.g., "Help me write a complete test suite for the 'Add Book' screen in my Android app").
Flip the roles: Instruct the AI to ask you targeted questions rather than immediately generating a solution (e.g., "Ask me questions one by one to collect the information you need").
Set the stopping constraint: Tell the AI when to stop asking questions and deliver the final output (e.g., "Continue asking questions until you have enough details to generate the complete test code").

Example Prompt Formula

"I want you to [Define Goal/Task, e.g., create unit tests for the 'Add Book' feature in Kotlin]. To do this accurately, ask me questions about my project requirements, data structures, and edge cases. Ask only one question at a time. Keep asking questions until you have all the information required to write the complete code, then provide the solution."