Part 2.4: Designing Better Prompts

Why Prompt Design Matters

Prompting isn’t just about getting an answer — it’s about designing a repeatable, reliable interaction between you and the model. When used in real-world tools, agents, workflows, or chatbots, prompts become production code. And like any other code, unclear prompts can lead to inconsistent behavior, errors, or unexpected outputs.

A well-designed prompt reduces confusion, improves relevance, helps ensure that the model performs the task you actually intend — not just what it guesses you meant — and contributes to safer, more reliable outputs.

• Inconsistent output? You might need better formatting cues.
• Hallucinated details? Your instruction may be too vague or open-ended.
• Overly verbose replies? You probably didn’t specify length or format.

Tip: Think of every prompt as a tiny design brief for an AI system. If a human would struggle to understand your instruction, so will the model.

Prompt design becomes even more important when:

• You’re using the same prompt many times (e.g., customer support summaries).
• You want the output to follow a particular structure (e.g., JSON or tabular data).
• You’re integrating the prompt into a product, tool, or automation pipeline.

The better your prompt is designed, the less trial-and-error you'll need — and the more trustworthy your AI system becomes.

Key Principles of Good Prompt Design

Once you understand why prompt design matters, the next step is learning what makes a prompt good. Strong prompts are not just clever—they’re clear, repeatable, and aligned with your intended outcome. Whether you're building a chatbot or generating structured data, these principles will help ensure your prompt performs well.

• Clarity – Make your instruction easy to understand. Avoid ambiguity. The model can’t read your mind.
• Specificity – State exactly what you want: task, scope, tone, format. The more vague you are, the more room the model has to misinterpret.
• Context (If Needed) – Add only the necessary background. Don’t overload the prompt with irrelevant information.
• Format Cues – Use keywords or structures (e.g., “Output:”, “List:”, or JSON tags) to shape the type of answer you want.
• Role Framing – Ask the model to act as a role (e.g., “You are a tax advisor”) to steer tone and expertise.
• Use Instructions Over Constraints – Instead of saying what not to do ("Don't write a long answer"), say what to do ("Limit your answer to 2 sentences"). It improves clarity and avoids confusion.

Tip: If your prompt has multiple goals, split it into two. It’s better to get one thing done well than two things poorly.

Prompt Design Patterns

Now that we’ve covered what makes a good prompt, let’s look at practical formats you can use. These reusable structures make it easier to design consistent prompts that work across tasks, tools, and models.

Instruction + Input + Output Format

Summarize the following paragraph in one sentence.
Paragraph: "OpenAI released a new language model that outperforms GPT-4 in several benchmarks."
Output:

This basic pattern helps the model understand what task you want, what content it should work with, and what the expected output should look like.

Role-based Framing

You are a UX designer helping a junior product manager rewrite confusing onboarding copy. Suggest an improvement to this message:
"Click here to continue your journey to full account activation."

Framing the model’s persona (e.g., “You are a UX designer…”) helps shape tone, domain knowledge, and decision-making.

Step-by-Step Format

Let’s solve this step by step:
A train travels 60 km in 1 hour. How far will it go in 4 hours?

A subtle but powerful format. Encourages reasoning and breakdown of logic before answering.

Delimiter-Based Formatting

### Task ###
Translate to French.

### Input ###
I’m learning how to write prompts.

### Output ###

Useful when you’re passing large inputs or need clear separation between parts of a task. Helps reduce ambiguity in both instructions and outputs.

Few-shot Examples

Text: That was amazing! // Sentiment: Positive
Text: I didn’t enjoy it. // Sentiment: Negative
Text: It’s okay. // Sentiment: Neutral

Embeds training-like examples in the prompt itself. Encourages the model to learn from the pattern before answering. This approach helps models perform classification, translation, or summarization with better alignment to your intended output style.

Prompt Templates with Variables

Prompt:
Write a one-sentence weather report for {city_name} based on the following forecast: {weather_data}

Example:
Write a one-sentence weather report for Tokyo based on the following forecast:
“Cloudy in the morning, 22°C high, light showers expected in the evening.”

Makes prompts reusable in software workflows or code. You define a structure once and inject variables dynamically.

Common Pitfalls and How to Fix Them

Even with the best intentions, prompt design can go wrong — especially when the instructions are vague, overloaded with information, or missing key context. Here are some of the most common mistakes, along with ways to improve them.

❌ Vague Instruction → ✅ Add Goal and Format

❌ Prompt:
Help me with customer service.

✅ Prompt:
Write a professional apology email to a customer who waited 3 days for a callback. Include next steps and contact info.

❌ Overloaded Prompt → ✅ Trim to Essentials

❌ Prompt:
Analyze this text, summarize it, rephrase it in simple English, and translate to Spanish.

✅ Prompt:
Summarize this text in one sentence using simple English.

❌ Missing Context in Multi-turn Prompts → ✅ Insert History

❌ Messages:
[{ "role": "user", "content": "What do you think of that idea?" }]

✅ Messages:
[
  { "role": "system", "content": "You are a startup advisor." },
  { "role": "user", "content": "We're building an AI tool to help recruiters." },
  { "role": "user", "content": "What do you think of that idea?" }
]

❌ Multiple Tasks at Once → ✅ Break It Down

❌ Prompt:
Write a summary, list pros and cons, and generate three tweet variations for this blog post.

✅ Prompt (Step 1):
Summarize this blog post in 2 sentences.

(Then follow up with separate prompts for the other tasks.)

Tip: The most common fix? Get more specific. One clear task per prompt, one clear output format, and just enough context to guide the model.

Prompt Optimization Tips

Prompt engineering is not a one-and-done task. Once you've designed a working prompt, it's worth testing, refining, and evolving it — especially if you're putting it into production or using it across multiple inputs. Here are some ways to optimize your prompts over time:

• Iterate and Observe: Run your prompt across varied examples and tweak wording, context, or output format based on what works best.
• Compare Models: Some prompts may perform better in Claude than GPT-4 or Gemini. Try your prompt across different providers to see what suits your task.
• Track Failures: Save examples where the model underperforms, and use them to revise your prompt or fine-tune few-shot examples.
• Template Your Prompts: Use placeholder variables (like {customer_name} or {input_text}) to make prompts reusable across tools and workflows.
• Mix Up Few-shot Order: In few-shot classification, randomize the example order occasionally to avoid the model overfitting to the first option.
• Adapt with Model Updates: Prompts that worked with GPT-3.5 might not behave the same with GPT-4-turbo. Re-test periodically as new models roll out.

Tip: Document your prompt iterations and their performance. In production, treat prompts like code — version them, test edge cases, and optimize over time.

Callouts & Tips

• Tip: You’re not writing poetry — you’re writing instructions. Be direct, structured, and clear.
• Watch for "Polite but Useless": Vague prompts often return polite replies that sound good but don't actually complete the task. Be specific about what the model should do.
• Track Your Prompts: If you're iterating prompts in a workflow or app, version-control them just like you would production code.
• Always Test with Real Inputs: Try your prompts with varied examples — edge cases, long inputs, or ambiguous phrasing — to see how well they hold up.
• Retry Strategically: If a prompt fails occasionally, consider retrying with a slightly rephrased variant or lower temperature. Sometimes a small nudge is all that's needed.
• Output Format Matters: Add cues like “Return in JSON” or “List 3 bullet points” to shape the model’s response, especially for structured outputs.