Simple prompting: less magic, more method

Most prompt-engineering advice is more complicated than it needs to be. I’ve tested a few thousand prompts in production, on AI products with real users, and the whole thing comes down to three principles. None of them involve magic words.

The three principles

1. Context is everything

Think about onboarding a new team member. You wouldn’t say “write me a blog post.” You’d explain the company, the audience, the tone, and what success looks like. Same with a model.

Good context includes:

• The role you want the model to play
• Who the output is for
• What you’re trying to achieve
• Any constraints or requirements
• Relevant background

The difference is stark:

Bad:  "Write a marketing email."

Good: "Write a marketing email for our AI software product. The
       audience is enterprise CTOs. Highlight our new security
       features. Professional but not stuffy. 200–300 words."

2. Structure breeds clarity

Structure your inputs and the outputs improve. A pattern that holds up:

Task: [What you want done]
Context: [Relevant background]
Format: [How you want it structured]
Constraints: [Limitations or requirements]
Additional Instructions: [Special considerations]

3. Iteration is the method

Your first prompt will be rough, which is fine. Start simple, see what comes back, then refine it. The thing that makes this work is being specific about what’s wrong:

Bad:  "Make it more formal."
Good: "Rewrite for a senior executive audience using business terminology."

Bad:  "This isn't quite right."
Good: "The tone is too casual for a technical whitepaper. Rewrite using
       more precise technical language."

The practical toolkit

Temperature

Temperature controls randomness in the output, typically from 0.0 to 1.0:¹

• 0.0 - deterministic, focused
• 0.2–0.4 - balanced; good for business writing
• 0.7–0.9 - more varied; good for brainstorming
• 1.0 - maximum randomness

Push it past the normal range and things get strange. On the OpenAI playground a temperature of 2 produces output that has stopped being useful.

Under the hood, temperature reshapes how the model samples from its next-token distribution. Lower values sharpen the distribution, making high-probability tokens more likely; higher values flatten it, giving long-shot tokens a chance.

Chain of thought

Want better reasoning? Ask the model to show its work, step by step.² It’s very good for checking that the model is making the decisions you’d make, and for spotting where it went off. It isn’t always appropriate, though. If you’re generating something an audience will read, you don’t want the reasoning sitting in the middle of it.

For manual iteration it’s ideal. To automate it you need one of these:

1. Ask for the reasoning inside <thinking> tags, then filter them out in code.
2. Multi-shot prompting. Pass the initial output back to the model to simulate the iteration.

Examples beat description

Nothing beats showing the model exactly what you want:

Format the output like this:
Title: [Example title]
Summary: [Example summary]
Key Points:
- [Example point 1]
- [Example point 2]

Now, using that exact format, write about [your topic].

This is especially useful for JSON. Before guaranteed structured outputs, a reliable trick was to show the shape and then seed the first token:

Format the output like this:
{
  "title": "[Example title]",
  "summary": "[Example summary]",
  "keyPoints": ["[Example point 1]", "[Example point 2]"]
}

Your output should start with { "title":

Seeding the opening { raises the probability the model produces valid JSON.

Common pitfalls

1. Too vague. “Make it better” is not a prompt.
2. Overcomplicating. Simple tasks don’t need fancy techniques.
3. Undercomplicating. There’s a spectrum, and the right amount of structure sits in the middle.
4. Forgetting the audience. Always specify who the output is for.
5. No constraints. Without boundaries you get meandering. Set the expected output.

Looking forward

Traditional prompt engineering will matter less as models get better at reading ordinary language. What sits underneath it, which is communicating clearly and being willing to try again, will matter more.

The simplest way to think about it: you’re working with someone who knows nothing about you, the problem or the context. Give them everything they need, or they’ll make it up. Getting better at that conversation beats crafting the perfect prompt.