Prompt guide per model: how to approach Claude, Gemini, and ChatGPT differently

This article falls within Module 2 — Using a model of the educational platform. Where the first module dwells on the processing of individual tokens and the underlying mathematics of transformer networks, in this phase we focus on the practical control of running language models. Formulating an effective instruction may seem universal at first glance, but leading AI models in practice respond very differently to the same text input.

The need for a model-specific approach

The idea that a single universal prompt works seamlessly on Anthropic Claude, Google Gemini, and OpenAI ChatGPT is a persistent misconception. Although all these systems are based on the transformer architecture, their further training trajectories differ drastically. The choices made during the alignment phase, the handling of system prompts, the implementation of reinforcement learning, and the fine-tuning for specific input formats determine how sensitive a model is to particular steering techniques.

An instruction that leads to a tight, structured answer with OpenAI's GPT models can provoke an overly cautious or, conversely, an excessively narrative response from Claude. Gemini, on the other hand, is designed from the ground up to handle diverse media types and direct integration with search ecosystems, which calls for specific handling of contextual sources. Anyone who understands and leverages the fine-grained differences between these three model families achieves significantly higher reliability and precision in automated workflows.

Anthropic Claude: System prompts, XML tags, and explicit frameworks

Anthropic's Claude models (such as the Claude 3 and 3.5 series) stand out for their excellent handling of long, structured texts and a sharp understanding of semantic hierarchy. Where other models get confused by extensive instructions, Claude thrives when instructions are clearly separated from data using XML tags.

Anthropic specifically trains Claude to recognize XML elements such as <instructions>, <context>, <example> and <output> as hard boundaries. This prevents the model from confusing the instructions with the accompanying documents — a crucial advantage for complex analyses or the secure processing of external data.

<system>
Je bent een senior data-analist gespecialiseerd in Nederlandse kwartaalrapportages.
</system>

<context>
Hieronder staat het ruwe financieel verslag van het afgelopen boekjaar.
[VOEG TEKST TOE]
</context>

<instructions>
1. Filter alle eenmalige omzetposten uit de analyse.
2. Formuleer de drie grootste operationele risico's.
3. Schrijf de samenvatting in formeel Nederlands.
</instructions>

<output_format>
Presenteer de risico's in een HTML-tabel met kolommen: Risico, Impact, Maatregel.
</output_format>

Another characteristic of Claude is its strong tendency toward nuance and avoiding absolute statements when the data is incomplete. As a developer, with Claude you sometimes need to explicitly grant permission to render a direct judgment, or conversely set strict constraints to prevent the answer from becoming overly cautious. When you include large amounts of background information, it's also advisable to place the actual source text at the top and close the prompt with the specific instruction at the very bottom.

OpenAI ChatGPT: Instruction following, JSON mode, and role assignment

OpenAI's ChatGPT family, powered by models such as GPT-4o and the specialized reasoning models in the o-series, is characterized by very high instruction following and streamlined handling of system and user roles. OpenAI places strict demands on adherence to constraints (such as a maximum word count or a mandatory JSON schema).

When prompting GPT models, using a clear role assignment (persona) in the systemprompt works especially well. The model uses this system instruction to sharply narrow the probability distribution of subsequent tokens toward the desired subject domain or writing style.

For applications that require structured data, OpenAI offers support for 'Structured Outputs'. Unlike regular prompts where you ask for JSON, the API uses grammar constraints to guarantee that the output complies with the given JSON schema. However, if you work through the chat interface or standard API prompts, it helps to include explicit 'few-shot' examples that show the exact input and output format.

If you want to compare specific performance on Dutch-language texts between the major providers, take a look at the Dutch-language content comparison between GPT-4o, Claude, and Gemini on the hub. There you can see how the language feel and grammar of the different model families play out on complex writing tasks.

Google Gemini: Multimodal context, search integration, and grounding

Google Gemini was built from its very first design as a native multimodal model. This means text, images, audio, and video are processed through the same internal representations. Where other models translate visual data through a separate vision module before processing, Gemini processes spatial and visual relationships directly within the context.

A second unique aspect of Gemini is its integration with 'Google Search grounding'. When Gemini is deployed with external search functions, the dynamics of the prompt change. In that case, the prompt must not only describe the task but also provide clear criteria for when the model should retrieve external information versus rely on the given context.

Gebruik voor het beantwoorden van de onderstaande vraag uitsluitend de meegegeven brondocumenten. 
Indien de informatie niet aanwezig is in de tekst, geef dit expliciet aan en start GEEN externe zoekopdracht.

[DOCUMENT TEKST]

Vraag: Wat zijn de exacte garantieverplichtingen bij schade door overmacht?

Gemini tends to structure answers visually and attractively, often with formatting using bullet points and headings. For concise, factual analyses, this can lead to unnecessary formatting. Explicitly specifying that an answer should be generated in plain text or without introductory pleasantries is needed more often with Gemini than with Claude or GPT-4o.

Systematic comparison of the three model families

To determine which model best fits your specific application, it's useful to compare the steering mechanisms and characteristics side by side. The table below gives an overview of the optimal way to prompt each model family.

System prompts and role assignment: What each model responds to

Assigning a specific role or 'persona' drastically changes a language model's behavior. However, the way this role is processed differs greatly between providers.

With OpenAI models, a role definition works best when it describes *how* the model should think and what *constraints* it has. A prompt such as "You are an expert lawyer" is often too noncommittal. Better is: "You are a legal advisor who reviews contracts against Dutch law. You only answer based on the Civil Code and cite the applicable article with every judgment."

With Claude, a role definition works best when combined with examples of the desired reflection. Claude uses the role to set the tone and depth of the framing, but needs guidance to prevent the model from giving an overly extensive discussion of every possible edge case.

With Gemini, it's advisable to link the role description to a clear target audience. Explicitly state who the answer is intended for (for example: "Explain this to a junior software engineer with no experience with distributed systems"). Gemini adapts its vocabulary and examples to this surprisingly effectively.

Chain reasoning: Steering Chain-of-Thought per model

Chain-of-Thought (CoT) means explicitly having a model lay out the intermediate steps of a reasoning process before giving the final answer. With standard models, this significantly increases accuracy on arithmetic or logical tasks. However, the way you activate this differs per model.

With Claude, you get the best results by asking the model to place its reasoning within specific XML tags, such as <thinking>...</thinking>, before the final answer in <answer>...</answer> is shown. This makes processing the output in software applications easy, since you can easily filter out the intermediate steps for the end user.

With OpenAI's newest reasoning models (such as the o1 and o3 series), manually adding "Think step by step" to the prompt is often redundant or can even backfire. After all, these models have a built-in reasoning mechanism that automatically processes extra computation steps before generating tokens. With regular models such as GPT-4o, however, manually enforcing intermediate steps remains a powerful method for preventing reasoning errors.

When a model fabricates factually incorrect details, the overview on hallucinations in AI models helps you recognize the causes of fabricated answers and resolve them through targeted reasoning steps.

Context management for extremely long documents

With the arrival of context windows ranging from hundreds of kilobytes to even several megabytes, it has become possible to include entire books, codebases, or file collections in a single prompt. However, the way models process this information is not the same everywhere.

The phenomenon where a model 'overlooks' information in the middle of a large body of text (the so-called 'needle in a haystack' problem) occurs to a greater or lesser extent with every model. To minimize this risk, we apply the following rules of thumb per model:

• Claude: Place all source documents at the top of the prompt, preferably separated with clear tags (for example <document_1>). Only close the prompt with the specific question or instruction.
• ChatGPT: For large texts, make sure to use clear section headings in Markdown. If the text is very long, it helps to briefly repeat the core instruction both at the beginning and at the end of the prompt.
• Gemini: Benefits from a clear table of contents or an overview of the structure preceding the long text. Specify exactly which chapters or paragraphs the model should focus on.

For developers who include larger volumes of documents, the analysis on context engineering and window management is essential for retaining relevant information within complex applications.

Measuring effectiveness and iteratively testing your prompts

Optimizing a prompt for a specific model is an empirical process. What looks like a small change in sentence structure at first glance can cause a significant increase or decrease in accuracy. To determine whether a change actually delivers an improvement, a structured testing method is necessary.

Testing instructions involves the following steps:

1. Assemble a fixed benchmark set: Collect at least 20 to 50 representative input examples with their corresponding desired outcomes (ground truth).
2. Isolate variables: Adjust only one part of the prompt at a time (for example, changing the role assignment or adding an XML structure).
3. Fix the sampling parameters: Make sure the temperature and top_p remain identical throughout the comparison test to rule out randomness in the generated outcome.
4. Evaluate the output objectively: Use automated evaluation scripts or automated judging models (LLM-as-a-judge) to test the output for accuracy and format consistency.

For those who want to fine-tune exactly how creative or strict the generated answers are, the guide on sampling parameters and temperature offers the technical depth needed to keep variation in test results under control.

To quantitatively test the quality of your adjusted instructions, you can apply the methodology for A/B testing of prompts within your test environment. This lets you replace gut feeling with hard statistical figures on model performance.

Common mistakes when prompting across models

In practice, we regularly see patterns that lead to reduced performance or unpredictable behavior when prompts are ported from one model to another. The most common pitfalls are:

1. Over-engineering with reasoning models: Adding extensive Chain-of-Thought instructions to models that already reason internally. This leads to duplicated processing time, higher token costs, and sometimes even confusion for the model.

2. Blindly carrying XML tags over to models not trained for them: Although GPT-4o understands XML tags, the model does not assign them the same strict hierarchical meaning as Claude does. With OpenAI, rely primarily on clear Markdown headings and explicit instructions.

3. Vague negative instructions: Telling a model what it *may not* do ("Don't use jargon") works less well across all three models than telling it what it *should* do ("Use language a high school student can understand"). Negative instructions require an extra logical step that increases the likelihood of errors.

4. Ignoring system roles: Dumping all instructions loose into the user prompt instead of making use of the systemfield. This reduces the consistency of the desired persona, especially during longer conversations.

Conclusion and practical recommendations

Effectively steering language models requires an adaptive approach. Anthropic Claude shows it excels when using XML tags and a clear separation of context and instructions. OpenAI ChatGPT calls for tight role assignments and structured schemas for reliable integration. Google Gemini thrives when multimodal input and search functions are offered with clear framing.

By tailoring your prompts to the specific characteristics of each model, you not only prevent hallucinations and faulty formatting, but also get the maximum return from the AI infrastructure you deploy.