Prompting That Works

Most disappointing AI answers are not the model's fault. They are the result of a request that left out something the model had no way to guess. A prompt such as "Write me a blog post about gardening" returns a bland, generic piece that could have come from anywhere, because that is exactly what the request asked for.

Good prompting is not a bag of magic phrases. It is clear communication with a very fast, very literal collaborator that knows a lot in general and nothing about the user's situation. This guide covers patterns that work across tools, with examples for writing, research, coding, and planning that can be adapted to many situations.

Because tools change constantly, the focus here is on principles that transfer from one model to the next. Specific menu names and features vary, so a tool's current documentation is the right place to check those.

What makes a prompt work?

A good prompt tells the model what is wanted, why it is wanted, who it is for, what material to use, and what a good result looks like. It supplies the context the model cannot know, states the format needed, and gives an example when style matters. Then the user reviews the output and refines it, treating the conversation as a draft loop instead of a one-shot vending machine.

Every pattern in this article is a way of delivering those ingredients. One principle matters most: the model can only work with what is in front of it. Whatever is left out, it fills with the most average guess.

Why prompts matter: a quick look under the hood

An LLM generates text by continuing patterns, one small piece at a time. The prompt is the starting pattern. Vague input points toward the vast middle of everything the model has seen, which produces generic output. Specific input narrows the target. A deeper explanation appears in how large language models work. For prompting, the practical consequence is simple: specificity is leverage.

Two other facts shape good habits. First, the model has a limited context window, so it only knows what is in the current conversation. Second, it has no idea whether the user is an expert or a beginner, a customer or a competitor, in a hurry or taking time, unless that is stated.

The anatomy of a strong prompt

Not every element is needed every time, but this checklist covers what usually improves results.

A weak prompt: "Write a service page for power washing."

A stronger prompt, as an example prompt: "Write a service page draft for a family-run power washing company that serves homeowners in two counties. Services are driveways, decks, siding, and fences. Tone is friendly and plain, no hype. Include a short intro, a list of what we clean, a three-step description of how a job works, and a closing call to action to request a free quote. About 350 words. Do not invent prices, guarantees, or years in business. Mark anything you are unsure about with brackets so I can fill it in."

The second version takes thirty seconds longer to write and can save ten minutes of fixing. The last two instructions deserve attention. Telling the model not to invent details and to flag gaps is one of the highest-value habits in prompting.

Pattern 1: Say who it is for and what it is for

The same task needs different output depending on audience and purpose. "Explain compound interest" could mean a middle-school lesson, a financial planning memo, or a podcast script. The prompt should say which.

Template: "Explain [topic] to [audience] so that they can [purpose]. Use [tone]. Length: [length]."

Example prompt: "Explain how a sitemap helps search engines to a small-business owner who has never heard the term, so that they can decide whether to ask their web developer about it. Friendly tone. About 150 words."

Pattern 2: Provide the raw material

Models do their best work transforming real material, not inventing from nothing. For a summary, the text should be pasted in. For copy about a business, the notes should be pasted in. For an email reply, the received email should be pasted in.

Template: "Here is the source material: [paste]. Using only this material, do [task]."

The phrase "using only this material" matters. It reduces the chance the model fills gaps with plausible invention. If something is missing, asking the model to say what is missing works better than letting it guess.

Pattern 3: Show an example of the target

When style is hard to describe, showing it works better. This is called few-shot prompting, and it is one of the most reliable techniques available.

Template: "Here are two examples of the style I want: [example 1] [example 2]. Now write one for [new subject] in the same style."

Example: Two product descriptions the writer likes are pasted in, followed by a request for a third about a new item. The model picks up sentence length, vocabulary, and structure far better than any adjective could convey.

The same approach works for puzzle and game content. A few existing clue styles can be pasted in with a request for more in the same register. The examples do the steering.

Pattern 4: Constrain the output

Constraints help the model. They narrow the possibilities and make results easier to use.

• Length: "Under 100 words." "Exactly five bullet points."
• Format: "Return a table with columns for task, owner, and due date."
• Style rules: "Use short sentences. Avoid passive voice. No buzzwords."
• Exclusions: "Do not mention competitors. Do not use the word 'revolutionary'."
• Structure: "Start with a one-sentence answer, then give three supporting reasons."

Machine-readable output for a script or spreadsheet can be requested directly: "Return valid JSON with these fields only." The result should then be checked to confirm that it parses.

Pattern 5: Ask for steps before the final answer

For tasks with several moving parts, asking for the plan first helps catch a bad direction early.

Template: "Before writing, outline your approach in five bullets. Wait for my approval before drafting."

For reasoning problems such as math, logic, or comparing options, the model can be asked to work through the problem step by step and show its reasoning. This often improves accuracy because each step conditions the next. Some tools offer built-in reasoning modes that do this automatically, and the details vary by product. Either way, the logic of anything important should be checked, because a clean-looking chain of steps can still contain a wrong turn.

Pattern 6: Let it ask questions

One of the most underused moves is inviting the model to interview the user.

Template: "I want to [goal]. Before you answer, ask me up to five questions that would help you do this well. Wait for my replies."

This works especially well for planning, strategy, and creative projects, where the user may not know what information the model needs. It also surfaces assumptions the user did not realize were being made.

Pattern 7: Assign a critic, not just a creator

Models are often better editors than first-draft writers, and that can be put to use.

Template: "Here is my draft. Act as a skeptical reviewer. List the five biggest weaknesses: unclear claims, missing evidence, awkward phrasing, anything a reader might misunderstand. Do not rewrite yet."

The next step is to request revisions based on the critique the writer accepts. Separating critique from rewriting gives more control.

A related technique is asking the model to argue the opposite side or to list what could go wrong with a plan. It will readily generate objections that had not been considered.

Pattern 8: Iterate in small moves

The first output is best treated as a draft. The most productive users refine with short, specific follow-ups.

• "Make the second paragraph more concrete."
• "Cut this by a third without losing the key point."
• "Keep everything, but change the tone to match the sample provided."
• "Give three alternatives for the headline."

Vague feedback like "make it better" yields vague improvements. Specific feedback, such as naming what felt off, gets a better result. If a conversation has gone sideways, patching it further is less effective than starting a new chat with the best version plus a cleaner instruction.

Prompts for writing

Writing is where most people start, and where the gap between a lazy prompt and a good one is largest.

Drafting from notes

Example prompt: "Turn these notes into a clear, friendly 300-word email to a customer explaining a delay. Notes: [paste]. Do not make promises about new dates unless they appear in the notes. Keep it apologetic but not groveling."

Matching a voice

Example prompt: "Below are three samples of my writing. Describe my voice in five bullet points: sentence length, word choice, tone, quirks. Then wait."

After the model responds, the next task can be pasted in with the instruction "Write this in the voice you just described." This two-step approach often beats a single instruction like "write like me."

Editing without losing meaning

Example prompt: "Edit this for clarity and concision. Preserve my meaning and voice. Show changes as a list of the five most important edits and then give the revised text. Do not add new claims."

Headlines, titles, and variations

Example prompt: "Give me ten headline options for this article, each under 60 characters, ranging from plain to playful. Avoid clickbait and avoid questions."

Local business copy

Example prompt: "Write a 100-word 'About us' blurb for a local cleaning company based on these facts only: [facts]. No claims about awards, years, or ratings unless I provide them. Use 'we' and 'our team.'"

That last constraint matters. Models tend to add flattering details that are not true, and with business pages, an invented claim can be a real problem. More on this appears in AI for small business.

Prompts for research

Research prompts need extra care, because this is where fabrication does the most harm.

Getting oriented on a topic

Example prompt: "I am new to [topic]. Give me a one-page overview: the key concepts, the main debates, and the five questions a beginner should ask. Flag which points are widely agreed upon and which are contested."

Summarizing a long document

Example prompt: "Summarize the document below in three parts: the main argument in two sentences, the five most important supporting points, and any claims that seem unsupported or need verification. Quote the exact sentences you rely on."

Asking for quotes makes it easier to check whether the summary matches the source.

Comparing options

Example prompt: "Compare [option A] and [option B] for [use case]. Use a table with these criteria: cost, learning curve, flexibility, and risks. Say clearly where you are uncertain, and tell me what I should verify on each vendor's own website."

Asking for sources, carefully

Example prompt: "List what you know about this topic, and for each claim say whether it is well established, commonly stated but uncertain, or a guess. Do not provide citations unless you can name a real, specific source I can look up. If you cannot, say so."

Models can invent plausible references. If a tool has live web search, the cited pages should be opened and read directly. If it does not, any citation is best treated as unverified until found independently. The underlying cause is explained in why AI makes things up.

A research workflow that holds up

1. Ask for an overview to learn the vocabulary.
2. Use that vocabulary to search real sources.
3. Paste the actual source text back into the model for summarizing or comparison.
4. Ask it to flag contradictions between sources.
5. Verify key facts directly before relying on them.

Prompts for coding

AI can speed up coding a great deal, especially for boilerplate, explanation, and debugging. The same principles apply, with a few extras.

Describe the environment

The language, framework, version if it matters, and constraints should be stated. "Write a JavaScript function" is much weaker than "Write a plain JavaScript function with no libraries that runs in the browser."

Be specific about inputs and outputs

Example prompt: "Write a function that takes an array of word strings and returns the ones that are valid for a five-letter daily word game: exactly five letters, only A to Z, no duplicates in the list. Include three test cases."

Debugging

Example prompt: "This code should [expected behavior] but instead [actual behavior]. Here is the code: [paste]. Here is the exact error message: [paste]. Explain the most likely cause first, then show the minimal fix. Do not rewrite unrelated parts."

The real error text should always be included. Paraphrasing it removes the clues the model needs.

Explaining code

Example prompt: "Explain what this function does line by line, as if to a beginner. Then point out any bugs or edge cases."

Refactoring safely

Example prompt: "Refactor this function for readability without changing behavior. List every change you made and why. Keep the public interface identical."

Safety rules for AI-written code

• Run it and test it. Generated code should never be assumed to work.
• Read it before using it, especially anything touching files, databases, passwords, or payments.
• Watch for invented functions or libraries. Models sometimes call things that do not exist.
• Do not paste secrets, such as API keys, passwords, or customer data, into a prompt.
• Keep changes small. Asking for one change at a time makes it easier to see what broke.

For browser games, a common flow is to ask for a minimal playable version first, test it, and then layer features in small steps. This approach is discussed in make a browser game with AI.

Prompts for planning

Planning tasks benefit from the model's ability to organize and brainstorm quickly, as long as real constraints are provided.

Project planning

Example prompt: "I need to launch a five-page website for a small business in four weeks, working about ten hours a week. Break this into weekly milestones with specific tasks. Flag the steps most likely to slip and suggest how to reduce that risk."

Decision support

Example prompt: "I am deciding between [option A] and [option B]. My priorities, in order, are: [list]. Ask me any questions you need, then lay out pros and cons for each tied to my priorities, and tell me what additional information would change your recommendation."

The output works best as a structured way to think, not as a verdict. For financial, legal, or medical decisions, it can help prepare better questions for a qualified professional.

Schedules and checklists

Example prompt: "Create a checklist for [event or process] with items grouped by when they should happen: two weeks before, one week before, the day before, the day of. Mark which items depend on others."

Content calendars

Example prompt: "Suggest twelve article topics for a site about [subject], each with a target reader, a working title, and one sentence on what makes it useful. Avoid topics that depend on current events."

Learning plans

Example prompt: "Create a four-week plan to learn [skill] at thirty minutes a day. Include one small project each week and a way to tell whether I am improving."

Using system instructions and custom settings

Many tools allow saving standing instructions, sometimes called custom instructions, a system prompt, or project instructions. These apply to every conversation, which removes the need to repeat the same preferences.

Good things to put there:

• The user's role and typical tasks.
• Preferred tone and formatting.
• Words, phrases, or habits to avoid.
• A reminder to flag uncertainty and not invent facts.
• Spelling conventions, such as American English.

Keeping them short and reviewing them occasionally is wise. Old instructions can quietly shape outputs in ways that are easy to forget. Feature names and limits differ by product and change, so the tool's settings page shows the current options.

Common mistakes and how to fix them

Mistake: Being vague

"Make this better" leaves the model guessing. Naming the problem is more effective: too long, too formal, unclear ending, missing a call to action.

Mistake: Asking for too much at once

A single prompt that demands research, a full draft, a design, and a promotion plan will produce shallow results on each. Splitting the work into steps is more effective.

Mistake: Burying the key instruction

In a long prompt, the most important instruction belongs near the beginning or end, with clear separators between instructions and pasted material. A label such as "Text to edit:" followed by the content helps the model tell them apart.

Mistake: Not saying what to avoid

A dislike of exclamation points, filler phrases, or a certain cliche should be stated. The model cannot guess a writer's pet peeves.

Mistake: Trusting confident answers

The tone of an answer says nothing about its accuracy. Names, numbers, quotes, and citations deserve verification. The explainer on what AI really is gives a broader view of what to rely on and what to check.

Mistake: Fighting a derailed conversation

Long chats accumulate clutter. If answers are drifting, starting fresh with a clean summary of the need is usually faster.

Mistake: Pasting sensitive information

Prompts are data sent to a provider. Passwords, financial details, private client information, and anything not meant to be stored should stay out. The guide on what not to tell a chatbot covers what to keep out and which settings matter.

Mistake: Expecting the same result every time

Output varies from run to run. A great result is worth saving. For repeatability, specific structure and examples help, and review remains necessary.

When prompting is not the problem

Sometimes no prompt will fix the issue, and it helps to recognize those cases.

• The task needs facts the model lacks. Supply them or enable a search tool.
• The task needs exact computation. Use a calculator, spreadsheet, or code execution.
• The task needs current information. Check whether the tool searches the web.
• The task depends on taste or judgment only the user has. Use the model for options, then decide.
• The model is simply weaker at this skill. Another tool may do better. Comparing outputs is cheap, and the guide to ChatGPT vs Claude vs Gemini shows how to do it by task.

A repeatable prompting workflow

Here is a simple routine that works for nearly any task.

1. Define the outcome. What will be done with the result? Who will read it?
2. Gather the materials. Facts, notes, examples, and constraints.
3. Write the prompt using the checklist: task, context, audience, constraints, format, and an example if style matters.
4. Ask for a plan or questions if the task is complex.
5. Review the first draft critically. Mark what is wrong or missing.
6. Give specific feedback in small steps.
7. Verify the facts, numbers, and claims that matter.
8. Save the prompt if it worked well, so it can be reused.

Keeping a personal library of working prompts is one of the best investments a regular user can make. Over time, templates build up for recurring tasks, and the results get steadier.

Prompts and agents

As tools gain the ability to take actions, such as browsing, running code, or editing files, prompting shifts from asking for text to assigning tasks. The same principles apply, with higher stakes: state the goal, the boundaries, what the tool may and may not do, and when to stop and ask. This is covered in AI agents explained.

Quick takeaways

• A good prompt supplies what the model cannot know: the goal, audience, context, constraints, format, and what success looks like.
• Provide raw material and say "using only this material" to reduce invented details.
• Show examples when style matters. Few-shot examples steer output better than adjectives.
• Ask for an outline or plan first on complex tasks, and invite the model to ask questions.
• Use the model as a critic as well as a creator, and iterate with small, specific feedback.
• For research, request uncertainty flags and verify any citation or fact independently.
• For code, include the environment and exact error messages, keep changes small, and always test.
• Never paste passwords, private data, or anything sensitive that should not be stored by a provider.
• When a conversation drifts, start fresh with a clean summary instead of patching.

FAQ

What is prompt engineering?

It is the practice of writing and refining instructions to get better results from AI models. For everyday users, it mostly means clear communication: stating the goal, giving context, setting constraints, and iterating. No technical skills are required. Developers building products around AI use more advanced techniques, but the basic principles are the same.

Are special magic words or "please" needed?

No. Politeness does no harm, and a respectful tone can make a writer's own instructions clearer, but no secret phrase unlocks hidden quality. What helps is specificity. Stating the audience, the format, and the constraints produces better results than any clever phrasing.

How long should a prompt be?

As long as it needs to be to carry the necessary context, and no longer. A simple task may need one sentence. A complex writing or planning task may need several paragraphs plus pasted material. Clarity matters more than length, so long prompts benefit from labels and separators.

Why does the AI ignore part of the instructions?

Long or crowded prompts can dilute attention, and conflicting instructions force the model to choose. Shortening the prompt, putting the key instruction first, using a numbered list of requirements, and repeating the most important rule at the end can all help. If a long conversation is the problem, starting a new one is often the fix.

Can a prompt stop an AI from making things up?

It can reduce the problem but not eliminate it. Instructions like "use only the text I provide," "say when you are unsure," and "do not invent sources" help. Enabling search or giving the model the relevant documents helps more. Important claims still need verification, because no wording makes the risk zero.

Should the same prompt be used on different AI tools?

Usually the same principles work across tools, but results differ in style and strength, so some tweaking is expected. Some models need less hand-holding and some follow formatting rules more strictly. Running important prompts on two tools and comparing is a reasonable approach, along with notes on what each does best.

What is the best way to get AI to write in a particular voice?

Providing real samples of the writing, asking the model to describe the voice, then using that description along with the samples in later requests works well. Adding explicit rules about words and habits to avoid helps further. Some editing is normally needed, since the match improves with iteration but is rarely perfect on the first try.

How can someone tell if a prompt is good?

The measure is the output and how much editing it needs. If the same problems keep recurring, such as wrong tone, missing details, or unwanted fluff, those fixes can be added to the prompt as explicit instructions. A good prompt is one that reliably produces a draft usable with modest edits.