Skip to content
Module
AI

Prompt engineering for Product Managers

Prompt engineering is the practice of writing and refining the instructions given to a large language model so that it produces the output you need, reliably. A prompt usually combines a task, the context the model lacks, constraints on format and tone, and sometimes examples of good answers. Inside a product, the prompt is part of the specification: it changes behavior as much as code does.

Definition written by Alex Dionisio, Senior Product Manager. Updated November 13, 2026.

Why it matters for a PM

PMs write prompts in two settings: for their own work (synthesizing feedback, drafting specs, preparing interviews) and inside the product (system prompts for assistants and AI features). In both cases the skill resembles writing a good brief for a colleague: say what success looks like, provide the necessary material, and check the result instead of trusting it.

Example

A PM asks an assistant to “summarize this user research”. The result is bland. The second version states the audience (the design team), the goal (pick two problems for next quarter), the format (a table of problem, evidence, frequency) and asks the model to flag any claim without a supporting quote.

Which prompt engineering techniques actually work?

A few techniques have proven themselves across most models. Setting a role and a precise context steers vocabulary and level of detail. Asking the model to reason step by step before concluding improves analytical tasks, and so-called reasoning models now do this on their own. Requiring structured output, such as JSON that follows a schema, makes the answer usable by code. Chaining several focused prompts instead of one giant prompt makes testing and debugging much easier.

By contrast, the magic formulas that circulate on social media (threats, promised tips, shouting in capitals) have uncertain effects that vary depending on the model. They never replace a clear instruction. Examples deserve care of their own: the model imitates them closely, so a set of examples that all share the same length or structure will push every answer toward that shape. Vary them on purpose.

Prompt engineering, RAG or fine-tuning: where do you start?

Prompt engineering almost always comes first: it costs only time, can be changed in minutes and tested right away. If the model lacks information, RAG or tools bring it the data. If, despite careful prompts and examples, the format or behavior stays unstable at high volume, fine-tuning becomes an option, with the added cost of preparing data and maintaining the tuned model.

The term context engineering describes the next step: designing not only the instruction but everything the model receives on each call (documents, history, tool results) and the order in which it arrives. In practice this is where many of the gains now come from: a well-written instruction cannot make up for a missing document or a cluttered history.

What is the PM's role in a product's prompts?

On a team, the PM can naturally take ownership of everything that is not code: what a good answer looks like, which cases must be covered, the tone, the expected refusals, how to behave if a needed fact is absent. Together these form a specification that the team turns into a prompt and a set of tests.

The PM can also propose changes directly, as long as the path is clear: the new version runs against the test set, its results are set against those of the live version, and someone signs off before deployment. A prompt edited outside that path is the equivalent of a hotfix pushed to production without review.

For personal work, the same discipline applies on a small scale: keep your best prompts in a shared document, note what worked and why, and reuse them instead of starting from a blank page for every synthesis or draft.

Key points

  • Clarity beats tricks: state the goal, the audience, the expected format and the fallback when facts are lacking.
  • Examples (few-shot prompting) teach format and tone faster than long descriptions.
  • Delimiters such as tags or headings separate instructions from the material to process.
  • A complex task works better as a sequence of steps or prompts than as one long request.
  • Production prompts are versioned and evaluated on a test set before each change.

Common mistakes

  • Editing a production prompt after one good try, without rerunning the cases that used to work.
  • Writing vague requests (“make it better”) and blaming the model for generic output.
  • Piling up instructions until they contradict each other.
  • Pasting confidential data into a tool whose terms allow training on it.

Go further with Module

The courses and lessons that cover this concept:

Guides on this topic