Prompt Engineering Fundamentals

We now know that modern LLMs are autoregressive models trained on massive text corpora and fine-tuned with human feedback. But how do you use them effectively as a developer?

Prompt Engineering is the art and science of communicating with LLMs to get reliable, high-quality, and structured outputs.

💡 Key insight: An LLM is a brilliant but amnesiac intern. It has absorbed broad patterns from training data, but it knows nothing about your current project unless you put that context in the prompt.

---

The chat API structure

When you use ChatGPT in the browser, you just type a message. But under the hood (and when you use the API), the conversation is structured into distinct roles.

A typical API request looks like this:

json
1[
2  {"role": "system", "content": "You are a senior Python engineer. Always reply with working code and no explanations."},
3  {"role": "user", "content": "Write a function to reverse a string."},
4  {"role": "assistant", "content": "def reverse_string(s):\n    return s[::-1]"},
5  {"role": "user", "content": "Now do it without slicing."}
6]

1. System Message: The persistent "rules of the game". It sets the persona, formatting rules, and constraints. It heavily anchors the model's behavior.
2. User Message: The specific request or question from the human.
3. Assistant Message: The model's previous replies. You pass these back in so the model has memory of the conversation.

Prompting map

Reliable prompts are built in layers. Put stable rules first, add trusted context and examples, isolate untrusted user data, then check the output shape.

Zero-shot vs few-shot prompting

A zero-shot prompt asks the model to do something without examples. It relies entirely on its pre-training.

User: Translate "hello" to French.

A few-shot prompt provides examples in the prompt to teach the model the exact format or logic you want. This uses the model's in-context learning ability, made famous by GPT-3.^[1]

User: English: cat -> French: chat English: dog -> French: chien English: bird -> French:

Few-shot prompting is incredibly powerful for forcing the model to output a specific JSON structure or adopt a weird, non-standard style.

Chain-of-thought prompting

One important prompt engineering discovery is chain-of-thought prompting.^[2]

If you ask an LLM a complex math question and demand the answer immediately, it will often fail. Why? Because of autoregressive generation. The model has to output the final number immediately based only on the prompt.

Standard prompt

Q: If John has 5 apples, gives 2 to Mary, buys 3 more, and cuts them all in half, how many apple halves does he have? A:

For standard models, one fix is to make intermediate reasoning visible: add a phrase like "Let's think step by step", or provide a few-shot example that includes reasoning.

Chain-of-thought prompt

Q: If John has 5 apples, gives 2 to Mary, buys 3 more, and cuts them all in half, how many apple halves does he have? A: Let's think step by step. First, John starts with 5 apples. He gives 2 away, leaving him with 3. He buys 3 more, giving him 6. He cuts 6 apples in half, yielding 12 halves. The answer is 12.

By generating the intermediate steps, the model adds them to its context window. It uses its output as a scratchpad, making the final answer easier to predict.

Some reasoning models do extra hidden reasoning internally before outputting the final answer, so explicit chain-of-thought prompts aren't always the right interface.^[3]

---

Best Practices for Developers

1. Be specific and use delimiters: Use markdown, XML tags (<data>...</data>), or triple quotes (""") to clearly separate your instructions from the user's data. This prevents prompt injection and confuses the model less.
2. Specify the output format: If you want JSON, ask for JSON and provide a schema.
3. Give the model an "out": Tell it: "If you don't know the answer based on the provided text, say 'I don't know'." This reduces hallucinations.
4. Repeat critical instructions near the end: Models can miss information buried in the middle of long contexts.^[4] If you have a 10-page document, put the core instruction close to the final user request.

Next, continue to The LLM Lifecycle, where prompting fits into training, alignment, and deployment.