Prompt Engineering Examples: 12 Ready-Made Templates for Work

Most articles about prompts explain theory, while the reader needs a template to paste and get a result. This is prompt engineering by example: twelve templates for summarizing, data extraction, classification, rewriting and analysis. Each comes with a note on why it is built that way, so you can adapt it to your own task.

All templates work with any model in the catalog. Curly braces {{...}} mark where you insert your own data.

The general scheme: what a working prompt contains

A good prompt answers four questions: what to do, on what data, in what format to answer, and what not to do. If one is missing, the model guesses and results drift between runs. Separate data from instructions with tags or triple quotes so the model does not mistake document text for a command. More on this in the article about system prompts→.

Prompt engineering examples: the templates

Summarization

1. Short summary with a limit

Why it works: the audience ("a manager who has not read it") sets the level of detail better than "briefly" or "in detail". The explicit ban on adding facts reduces invention.

2. Bullet digest with decisions

Why it works: fixed headings turn free text into structure, and the "not specified" rule stops the model from inventing owners.

Data extraction

3. Fields as JSON

Why it works: a schema with types and null for missing values makes the answer predictable. How to guarantee valid JSON is covered in the article on structured output→.

4. Extraction with a confirming quote

The quote lets you check the answer by eye and filter out false hits.

Classification

5. One label from a closed list

6. Classification with examples

Why it works: a closed list and a one-word answer simplify parsing in code. Two or three examples set the boundaries better than a description; see the article on few-shot prompting→.

Rewriting

7. Change tone, keep meaning

8. Simplify for a new reader

Why it works: two constraints ("do not change meaning", "no longer than") keep the model from improvising. Without them a model often lengthens the text.

Analysis

9. Pros, cons, risks

10. Code review

11. Comparing options

Working from a source

12. Answer only from the document

Why it works: the permitted phrase "the document does not say this" gives the model a way out, so it does not make things up. This is the basis of knowledge-base search.

Calling a template from code

All twelve templates drop into the same call. A Python example with the OpenAI SDK, with the key read from an environment variable:

import os
from openai import OpenAI

client = OpenAI(base_url="https://api.zukko.pro/v1", api_key=os.environ["ZUKKO_API_KEY"])

TEMPLATE = """Shorten the text to 5 sentences for a manager.
Keep numbers, dates and names. Do not add anything that is not in the text.

<text>
{text}
</text>"""

def summarize(text: str) -> str:
    r = client.chat.completions.create(
        model="deepseek-v4.1-flash",
        messages=[{"role": "user", "content": TEMPLATE.format(text=text)}],
        temperature=0.2,
    )
    return r.choices[0].message.content

For tasks with an exact answer (extraction, classification) keep the temperature low; for rewriting it can be higher. Note that some newer models ignore temperature or reject it: if you get a 400 error, drop the parameter.

What one call costs

Prices as of October 18, 2026, $ per 1M tokens. Take summarization with illustrative volumes: 3000 input tokens, 300 output.

For a thousand documents that is about $0.05 and $1.80. Which model is enough is decided by testing on your texts, not by a table: run 20-30 samples through both and compare. How to set that up is in the article on testing prompts→. For current prices use GET https://api.zukko.pro/v1/models or the "Models" page in the dashboard.

Common mistakes

• Instructions and data are mixed in one paragraph, and the model follows commands from the text itself.
• No answer format, so the code receives text with an intro like "Sure, here is the result".
• Vague words: "make it good", "briefly". Replace them with measurable conditions: number of sentences, audience, list of fields.
• No way out for the model: if the answer is not in the data, it must be allowed to say so.

FAQ

How many examples should a prompt contain?

Two or three different ones are usually enough. Add more only if testing shows errors of a particular kind; then add an example for exactly that case. Each example adds input tokens to every call.

One long prompt or several short ones?

If the task consists of independent steps (extract, then classify, then rewrite), a chain of short prompts is easier to debug and check. One long prompt costs fewer calls but makes it harder to see where the error happened.

Do the templates work for English?

Yes, the structure is the same. You can write the instruction in English and keep the data in Russian; test both variants on your texts.

Should I ask the model to "think step by step"?

For complex calculations and analysis it sometimes helps, but it increases output tokens, which cost more than input. Check on examples whether it improves accuracy for your task.

To try the templates, create a key in the Zukko dashboard and put it into the code above. Payment: SBP, cryptocurrency or MasterCard cards, top-ups from $1.