AI is magic, right? Yeah… sort of.
Let me explain, with modern neural network models we have reached amazing results that were in our dreams only two years ago, but hey there is a ton of data (the “knowledge”) waiting for us to be queried simply by writing a prompt.
The prompt is the way we can communicate with the AI, or better the large language model (also called LLM).

However, if it’s true that we are using our language to ask the model to answer us, is there a way to make the communication more efficient? You can see that dialogue like you and a foreigner that is trying to talk in your language but his first language is not yours, it’s simply a collection of numbers.
So there are different techniques that we can use to make those numbers talk to us, that are called patterns.

Role prompting pattern

This is the basic pattern that is often use to start a prompt with a generic purpose LLM. When we open the ChatGPT or Gemini interface, we can simply type something as if you were using Google Search. On modern models the results are good enough if you want to perform a quick search in the model knowledge, but not if you want some accurate answers about a specific argument or task.
Imagine the model like an high skilled, omni-comprehensive trained human that can answer you to anything you are asking, the real challenge is not just getting a good answer, but getting one that’s narrow and precise enough for your specific need.

The pattern is the following one:

You are a [role] with [characteristics/expertise]. 
Your task is to [objective].

But let’s make an example:

You are a botanist with over 10 years of experience, and you know every species of plants and flowers, specifically succulent plants.
You need to tell me how i can grow up wealthy and strong two aloe plants i have exposed on my terrace oriented to south in northern italy area. I'm not an expert, but an hobbyist that likes his house more greener.

This approach doesn’t just ask for general advic, it instructs the model to focus only on the relevant knowledge. It also provides context about my skill level, so the response can be adjusted to my experience.

Ok cool, you can say, but the role pattern is not a way that can be use to communicate: we are only trying to define some boundaries that should be respected, so how we can make a dialogue more efficent?
Well there are different additional pattern that we can use, the following list is not exaustive, but those are the patterns that I think are relevant to know to get a very effective answers.

Flipped interaction pattern

This pattern is interesting because it forces the LLM to ask us question to refine answers and statements to our requests.
In recent days several agents (like Claude Code, well known to developers) are already integrating some features that, thanks to newer reasoning models, are more prone to ask questions to the user to achieve better results.
However if you interact with LLMs via their web interfaces, it should be helpful to know.

It consists in one fundamental point:

Before answering, ask me [number] clarifying questions to achieve [task]

And let’s make the usual example:

I would like to ask me 5 questions to help me resolve some issue with my car. I'm currently have some squeaking sound from the front left tire that is noticeable while I press the brake pedal while I'm driving.

I pasted this example to Gemini 3 Pro, and that was the output:

To narrow this down so you aren't throwing money at parts you don't need, answer me these five things:
1. Does the squeak happen every time, or only when the brakes are cold/hot?
2. Is it a high-pitched metallic "chirp" or a deeper "groan"?
3. Do you feel a pulsation in the brake pedal or a pull to one side?
4. Does the sound change based on your speed?
5. Does the noise happen if you turn the wheel while braking?

So this pattern not only help the AI to give us a better answer, but also it help us to identify in a better way what’s the issue and reflect on some points that maybe we wasn’t taking care of.

Few-shot pattern

Few-shot is one of the most used and popular patterns that are currently adopted. To get a better answer to our questions, we can help the LLM by providing some examples of what the input looks like and what we expect to receive as output.

This pattern is very powerful in situations where the style or the tone of the conversation is easier to show than to describe. It is also popular among developers because the output can be controlled in some way (for example, from a given input, return a JSON formatted in a specific way).

Here are some examples: 
Input: [example 1 input] Output: [example 1 output] 
Input: [example 2 input] Output: [example 2 output] 
Input: [example 3 input] Output: [example 3 output] 

Now, apply the same logic: 
Input: [your actual case] Output: 

And that’s an example:

Here are some examples of how I want you to rewrite casual messages into a more professional tone:

Input: "Hey, did u receive my email?"
Output: "Hi, I wanted to check if you’ve received my email."

Input: "Can u send me the report now?"
Output: "Could you please send me the report when you have a moment?"

Input: "Sorry for the late reply, I was busy."
Output: "Apologies for the late reply; I was busy earlier."

Now rewrite this one in the same professional style:
Input: "What about the meeting? Are we going to reschedule?"
Output:

Template pattern

Sometimes we use LLMs to get information to compile or prepare documents, reports, or articles.
The model, however, often responds to our question in a colloquial way, without a defined schema… unless we tell the model to do so.

This pattern is called template, because we can explain to the model the exact format of the output we expect to receive after our question.

We can enrich the template with placeholders, to tell the LLM where information should be placed, so the same template can be reused for multiple questions that share the same output format, filled with the correct data.

Replace [Y] with a placeholder, such as [<PLACEHOLDER>]. Then, define a general pattern that illustrates how the output should be structured — for example, "<FIELD 1>: <VALUE 1>", ": ", or any other format suitable for your use case.

A little bit cryptic, right? Let’s see an example:

Analyze this restaurant based on the provided reviews: "[REVIEWS]". 

Respond **only** in this exact format: 

**Name**: <NAME> 
**Overall Score**: <SCORE>/10 
**Strengths**: <LIST 3 POINTS> 
**Weaknesses**: <LIST 2 POINTS> 
**Recommended for**: <CUSTOMER TYPE>

So if you paste this prompt in your preferred LLM and fill in the [REVIEWS] with a comprehensive list of reviews of the restaurant you want to analyze, the result will be pretty impressive:

Name: Il Porticciolo
Overall Score: 10/10
Strengths:
- Excellent fresh lake fish buffet and spectacular first courses, including grilled options.
- High-quality dishes with generous portions, especially pasta specials like tagliatelle with lavarello and truffle.
- Elegant, pleasant lakeside ambiance with wide menu selection.
Weaknesses:
- No weaknesses identified in provided reviews.
- Limited review sample size.
Recommended for: 
- Food enthusiasts seeking refined Italian lakeside dining with fresh seafood

Ask for input pattern

Absolutely one of my favourite when I was a student: this pattern allows the model to interact back with you by making specific questions the AI would need to answer to your request, one by one in a sort of interactive form:

You are an expert in [DOMAIN]. Task: [TASK].

**Before starting, ask me for:**
- [INPUT 1]
- [INPUT 2]
- [INPUT 3]

No assumptions. Once provided, proceed.

**Ask now: "[INITIAL QUESTION]".**

This pattern may sound similar to flipped interaction, but the in the first one you are forcing the LLM to ask you questions about the topic you want to discuss but in reality the LLM can work without it, in this one this questions are relevant because this detail is missing. Let’s make an example:

You are a cooking expert. Task: create recipe. 

**Before starting, ask me for:** 
- Dietary preferences 
- Available ingredients 
- Cooking time No assumptions. 

Once provided, generate recipe. 

**Ask now: "Preferences, ingredients, time?"**

Now why this is powerful (at least to me)? Because you can use this pattern to create custom GPTs or Gem that, if you provide your multiple or single selection questions list that you are using to train preparing your exam, it will iteratively present you a question and ask for the input to evaluate if your answer is good or not.

This is my personal statistics exam training prompt:

You are a university professor teaching probability and statistics. I need you to help me practice in this way: you will find 9 PDF files in your knowledge, containing exercises/quizzes that are grouped in "Part A" of each file. Each quiz is multiple choice, with only one correct answer.

When I say "go," you must propose one of these questions randomly selected from any of the files and wait for my response. I will give you an answer and you must tell me if it is correct or incorrect. In both cases, you must explain the answer to me. At the beginning of each session, you must shuffle the files.

Once you have given me the answer, you will wait for another "go," only then will you give me another question to answer.
You must remember the questions you ask me, so when I return later and ask for a question, you won't keep asking me the same ones. 
When you have finished proposing all the questions, you can re-propose the ones you have already asked me.
If I say "skip," you will skip the question and move to the next one.

So I hope that this brief list of examples and patterns, not a complete list but a good starting point, helps someone learn how this AI revolution also requires some effort from us (humans? :)) to understand how we should write or talk to get really good answers.

Cover image: Midjourney
Text: Me 🙂 (grammar corrections made with Gemini 3 Pro)