Humanity’s Last Prompt Engineering Guide: Built for the Agent Era

The first editions of this guide were written for chatbots. You typed a question, the model typed an answer, and most of the skill was in the phrasing. That world is mostly gone.

Today’s models think before they answer. They read entire folders of documents, call tools, browse the web, and work for minutes or hours on their own. The old tricks, like magic phrases, elaborate role-play, and “think step by step,” matter much less. What matters now is what any good manager already knows: a clear goal, the right context, and a definition of done.

This edition doesn’t name model versions on purpose. The advice applies whether you use ChatGPT, Claude, Gemini, or an open-weight model, and it should keep holding up as new versions ship.

What Changed

• Models reason on their own. Frontier models plan internally before responding, and many apps let you choose how much effort they spend.
• Context windows are huge. You can hand over a full contract, a transcript, or a whole project. Space is rarely the bottleneck anymore. Choosing the right material is.
• Models use tools. Search, code execution, file access, and app connectors mean the model can go get what it needs, as long as you tell it what’s allowed.
• Agents run long tasks. Instead of asking for one answer, you hand off a job. A prompt is now closer to a brief than a question.
• Models follow instructions literally. Newer models do what you say, not what you meant. Vague prompts get generic work, and contradictory prompts get confused work.

Anatomy of a Modern Prompt

A strong prompt answers five questions. Short requests don’t need labels, but for anything that matters, cover all five.

1. Goal. What are you trying to accomplish, and why? The why lets the model make good judgment calls you didn’t anticipate.
2. Context. What does the model need to know? Background, audience, source documents, earlier decisions, what you’ve already tried.
3. Constraints. What must it do or avoid? Length, tone, sources, which tools it may use, anything that’s off limits.
4. Output. What should the result look like? Format, structure, level of detail, and where it will be used.
5. Done. How will you know it worked? A checklist, a test, or a quality bar the model can check itself against.

Context Beats Cleverness

Most bad AI output isn’t a phrasing problem. It’s a context problem. The model didn’t know who the audience was, what had been tried, or what good looks like at your company, so it filled the gaps with the most generic answer available.

• Give it the real material: the email thread, the spreadsheet, the draft, the style guide. Your summary loses the details that matter.
• Explain the situation the way you would to a sharp new hire on their first day.
• Say what you already know and what you’ve ruled out, so the model doesn’t spend its effort rediscovering it.
• Share an example of great output if you have one. One good example beats a paragraph of adjectives.
• Cut what’s irrelevant. Stale or contradictory material hurts quality as much as missing material does.

Prompting Reasoning Models

Reasoning models plan before they respond, which changes a few old habits.

• Skip “think step by step.” The model already does that. Spend those words on context instead.
• Describe the outcome, not every step. Give the goal and the constraints, then let the model choose its approach. Scripting the method often produces worse work than describing the result.
• Match effort to the task. Use faster modes for rewrites and quick lookups. Save deeper reasoning for analysis, planning, math, and code.
• Ask for the judgment calls, not the scratchpad. If you want to see the reasoning, ask for a short explanation of the key decisions rather than every thought along the way.
• Invite pushback. “If my premise is wrong, tell me” gets a better answer than a model politely working around a bad assumption.

Briefing an Agent

When a model can browse, run code, edit files, or act inside your apps, your prompt becomes a work order. Write it like one.

• Describe the end state. “Leave a draft in the shared folder and a summary of what changed” beats “work on the report.”
• Set permissions explicitly. Say what it can touch and what needs your approval first. Sending email, deleting files, spending money, and posting publicly should almost always wait for a yes.
• Name the sources of truth. Point it at the right folder, repo, or dashboard so it doesn’t guess.
• Ask it to check its own work. Run the tests, re-check the numbers against the source, open the page and look at it.
• Ask for an honest report. What was done, what was skipped, and what it’s unsure about. A good agent tells you where it got stuck.

What You Can Stop Doing

• Magic phrases. “You are a world-class expert,” offering tips, or saying your job depends on it. Modern models don’t need flattery or pressure. They need information.
• ALL CAPS and repeated warnings. Newer models take instructions seriously the first time. Shouting tends to make them rigid and overcautious.
• Mega-prompts for multi-stage work. Ask for a plan, review it, then let the model execute.
• Negative-only instructions. “Don’t be wordy” works worse than “under 150 words, plain language, no preamble.”
• Assuming it knows today’s news. Unless the model is searching, its knowledge has a cutoff. Give it current facts or let it look them up.

Structure for Long Prompts

• Separate instructions from material. Wrap documents in clear labels or tags like <contract>...</contract> so the model never confuses source text with your instructions.
• With long documents, put the material first and your question last.
• If the output feeds another tool, show the exact format: a sample JSON object, a table header, or a template with blanks.
• When accuracy matters, ask for direct quotes or citations, then spot-check a few.

Make Good Context Reusable

If you find yourself pasting the same background into every chat, stop. Most AI apps now let you save context once and reuse it.

• Custom instructions hold who you are, how you like answers formatted, and what to avoid. Keep them short and specific.
• Projects and workspaces hold the files a body of work depends on: style guides, product docs, past examples.
• Memory picks up preferences over time. Check what it has saved now and then, and delete anything wrong or outdated.

Treat these like a shared doc for a new teammate. Update them when something changes, and cut anything that no longer applies.

Iterate Like an Editor

Your first prompt is a draft. The fastest path to great output is a tight loop.

1. Run it and read the output critically.
2. Diagnose the miss: missing context, an unclear goal, the wrong format, or a task that was too big for one pass?
3. Fix the prompt, not just the answer. If you’ll do this task again, save the improved version as a template, custom instruction, or project file.
4. For recurring work, keep a few test cases and re-run them when you change the prompt or switch models.

You can also ask the model for help: “Here’s my prompt and the output I got. What was missing or ambiguous?” Models are good at critiquing prompts, including their own.

Templates

Read a Document for a Decision

Write in Your Voice

Plan Before You Build

Pressure-Test an Idea

The Prompt Scorecard

Before you hit enter on anything important, check:

• Did I say what I’m trying to accomplish and why?
• Did I give it the real material instead of my summary?
• Did I say who the output is for and what format it needs?
• Did I set limits on what it can do or touch?
• Did I tell it how I’ll judge whether the result is good?
• Is there anything a smart new hire would need to ask me before starting?

That last question sums up the whole guide. Brief the model like a capable colleague who has never met you, and you’ll get work that reads like it came from someone who knows you well.