Common prompting mistakes and how to fix them

You ask ChatGPT to "make this email better," and it hands back something blander than what you started with. The model did exactly what you said. The problem is what you said.

Most bad AI output comes from three repeat-offender mistakes: asking vaguely, cramming ten requests into one prompt, and assuming the model remembers a conversation it never saw. Fix these three and your results improve immediately. Here's each one with a before-and-after.

Mistake 1: the vague ask

A vague prompt forces the model to guess. It will guess, confidently, and often wrong. The fix is to add context: who it's for, what "good" looks like, and any constraints.

Before

Make this email better. "Hi, just checking if you got my last message about the invoice. Let me know. Thanks."

You'll get a generic rewrite. Longer? Shorter? More formal? The model has no idea, so it picks for you.

After

Rewrite this email to a client who owes us $4,000 and has gone quiet for two weeks. Keep it polite but firm, under 80 words, and end with a clear next step (a payment link). Match a professional but warm tone. "Hi, just checking if you got my last message about the invoice. Let me know. Thanks."

Now the model knows the stakes, the length, the tone, and the goal. The output goes from filler to usable.

The pattern: role, task, context, format

A reliable structure for any ask:

• Role: "You are a contracts lawyer reviewing a freelance agreement."
• Task: "Flag any clause that puts the freelancer at risk."
• Context: "This is for a solo designer in the US, paid per project."
• Format: "List each risk as a bullet with a one-line plain-English explanation."

You don't need all four every time. But when output disappoints, the missing piece is almost always one of these.

For a deeper reference, Anthropic's free prompt engineering guide breaks these elements down with examples you can copy.

Mistake 2: stacking ten requests into one prompt

When you ask for everything at once, the model spreads its effort thin and drops half your requirements. This is the most common reason people think AI "can't follow instructions."

Before

Read this 20-page report, summarize it, translate the summary to Spanish, pull out the three biggest risks, write a tweet about it, suggest a chart, and draft an email to my boss.

The model will attempt all of it and do most of it badly. The tweet will be weak, a risk will be missing, the summary will be rushed.

After: Break it into steps

Run these as separate prompts, in order:

1. "Summarize this report in 200 words, focused on financial outcomes."
2. "From that summary, list the 3 biggest risks, ranked by likelihood."
3. "Draft a 4-sentence email to my manager covering the summary and the top risk."

Each prompt gets the model's full attention. You also get to inspect each result before moving on, so errors don't cascade.

When to chain vs. when to combine

Combining a few *related* tasks is fine: "Summarize this and list three takeaways" works well. The trouble starts when tasks are unrelated or depend on each other. A good rule: if a step's output becomes the next step's input, run them separately so you can check the handoff.

If you do this often, you can automate the chain with a quick script. Here's a minimal example using the OpenAI APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.View full definition → in Python:

from openai import OpenAI
client = OpenAI()

report = "...paste your report text here..."

# Step 1: summarize
summary = client.responses.create(
    model="gpt-5.1",
    input=f"Summarize this report in 200 words, focused on financial outcomes:\n\n{report}"
).output_text

# Step 2: use the summary to find risks
risks = client.responses.create(
    model="gpt-5.1",
    input=f"From this summary, list the 3 biggest risks ranked by likelihood:\n\n{summary}"
).output_text

print(summary)
print(risks)

Notice each call does one job, and the summary is passed explicitly into the next step. That explicit passing is the whole point, which leads us to the third mistake.

Mistake 3: assuming the model remembers another chat

People constantly open a fresh chat and write, "Now turn that into a slide deck." The model has no idea what "that" is. It cannot see your other conversations, your last session yesterday, or what you told a different tool.

Each conversation is a sealed room. The model only knows what's in the current window (everything you and it have said *in this thread*). This is called the context windowcontext windowThe context window is the maximum amount of text (measured in tokens) a language model can process at once, including both the input prompt and the generated output.View full definition →: the working memory of a single chat.

Before

You spent an hour yesterday building a marketing plan in one chat. Today you open a new chat and type:

Turn the plan into a one-page summary.

The model replies asking what plan, or worse, invents one.

After

Either continue in the *same* chat, or paste the relevant content into the new one:

Here is the marketing plan we'll work from. Turn it into a one-page summary with sections for Goals, Channels, and Budget. [paste the plan]

If it's there in front of the model, it works. If it isn't, the model is guessing.

What about "memory" features?

In 2026, ChatGPT, Claude, and Gemini all offer some form of saved memory or projects that persist facts across chats (your name, your writing style, an ongoing project's files). These help, but don't rely on them for specifics:

• ChatGPT Projects and Claude Projects let you attach files and instructions that stay available across every chat *inside that project*. Use these for ongoing work.
• Memory stores small facts ("I'm a teacher in Madrid"), not full documents. Don't assume it remembers yesterday's 2,000-word draft.

When in doubt, paste it in. Pasting is free and reliable. Assuming is neither.

Putting it together: a real rescue

Here's a single weak prompt fixed using all three lessons.

The original (all three mistakes at once)

Help me with my course launch. Make it good and also remember the pricing from before.

Vague ("make it good"), overloaded ("help with my course launch" is a hundred tasks), and assuming memory ("the pricing from before" the model never saw).

The rewrite

First chat, one focused task with full context:

You are a launch copywriter. Write the announcement email for my online course "AI for Teachers." Audience: KKThe average number of new users each existing user generates through referrals. Above 1.0, growth compounds on itself and becomes exponential.View full definition →-12 teachers, mostly non-technical. Price: $149, with a $99 early-bird for the first 100 sign-ups. Tone: encouraging, no hype. Length: under 150 words, ending with a sign-up button labeled "Reserve my spot."

Then, *next* task in the same thread (so the context carries):

Now write 3 subject lines for that email, each under 50 characters.

One clear ask at a time, all context supplied, no reliance on the model's memory. The output will be sharp on the first try.

A quick self-check before you hit enter

Run any prompt through these three questions:

1. Could a stranger do this task from my prompt alone? If not, add context (Role, Task, Context, Format).
2. Am I asking for more than one or two related things? If yes, split it into steps.
3. Does my prompt reference something the model can't see? If yes, paste it in.

Thirty seconds of checking beats three rounds of disappointing output.

Key Takeaways

• Replace vague asks with structure. Add who it's for, what "good" means, and the format you want. "Rewrite this in under 80 words, polite but firm" beats "make it better."
• One job per prompt. Chain complex work into separate steps, and feed each step's output into the next so you can check the handoff.
• The model only sees the current chat. It has no memory of other conversations or other tools. Paste in anything it needs.
• Use Projects for ongoing work. ChatGPT and Claude Projects keep files and instructions available across chats, but don't trust general "memory" with full documents.
• Self-check in 30 seconds: Could a stranger do it? Is it one task? Can the model actually see what I'm referencing?