DEV Community: Prabhakar

Advanced Prompting Techniques — Automating Reasoning & Persona-Based AI(Part 3)

Prabhakar — Sat, 31 Jan 2026 19:41:48 +0000

In Part 1, we learned what LLMs are and how they work.
In Part 2, we explored basic prompting and Chain-of-Thought reasoning.

Now in Part 3, we go deeper into advanced prompting techniques that help you build Agentic AI systems instead of simple chatbots.

In this section, we dive into one of the most important skills in the Agentic AI journey: Prompting.

A good prompt can improve your LLM’s output by 10x–20x in quality and accuracy.
A bad prompt leads to vague, unpredictable, or wrong answers.

In this guide, you’ll learn:

What prompting really means
Why system prompts matter
Zero-shot prompting
Few-shot prompting
Chain-of-Thought (CoT) prompting

1. What Is Prompting?

A prompt is the instruction you give to an LLM to control how it behaves and responds.

Without a prompt, the model behaves like a free-flowing chatbot:

“Hey, who are you?”
→ It can answer anything: math, jokes, code, history… anything.

That’s not ideal in real applications.

Instead, we give a System Prompt — a special instruction that sets context and boundaries.

Example: System Prompt

You are an expert in mathematics.
Only answer math-related questions.
If the user asks anything else, say "Sorry, I can only help with math."

2. Zero-Shot Prompting:

Zero-shot prompting means giving direct instructions with no examples.

You tell the model exactly what to do.

Example:

from openai import OpenAI

def ask_model(message):

    client = OpenAI("API_KEY")

    # Zero shot prompt: directly giving the instruction to the model
    SYSTEM_PROMPT = "You should only and only ans coding related questions, Sorry i can give you only coding related ans"

    response = client.chat.completions.create(
        model="gemini-3-flash-preview",
        messages=[
            {   "role": "system",
                "content": SYSTEM_PROMPT
            },
            {
                "role": "user",
                "content": message
            }
        ]
    )

    return response.choices[0].message.content

print(ask_model("Hey, I am Prabhas"))
print(ask_model("Please, Write the a program to calculate the factorial of 5 java"))

**Output:**
1. Sorry, I can only answer coding-related questions. Please let me know if you have any questions regarding programming, algorithms, or software development.

2. Here is a simple Java program to calculate the factorial of 5 using a `for` loop:

java public class Main {
    public static void main(String[] args) {
        int number = 5;
        long factorial = 1;

        for (int i = 1; i <= number; i++) {
            factorial *= i;
        }

        System.out.println("The factorial of " + number + " is: " + factorial);
    }
}

No examples
Direct command
Fast, but less accurate than other methods

Use Zero-Shot when:

The task is simple
You don’t need much reasoning

3. Few-Shot Prompting

Few-shot prompting provides examples along with instructions.

This teaches the model how you want it to behave.

Example:

from openai import OpenAI

client = OpenAI("API_KEY")

SYSTEM_PROMPT = """
You should only and only answer coding related questions.
If the user asks something other than coding, return JSON with:
- code: null
- isCodingQuestion: false

Rules:
- Strictly follow the output in JSON format.

Output format:
{
  "code": "string" or null,
  "isCodingQuestion": boolean
}

Example:
Q. Can you explain a + b whole square?
A. {
  "code": null,
  "isCodingQuestion": false
}
"""

def ask_model(user_message: str) -> str:
    """
    Sends a prompt to the LLM and returns the response.
    """
    response = client.chat.completions.create(
        model="gemini-3-flash-preview",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": user_message}
        ]
    )
    return response.choices[0].message.content


# Example usage
    print(ask_model("Hey, I am Prabhas"))
    print(ask_model("Write a Python function to reverse a string"))

Output:-
1. {
  "code": null,
  "isCodingQuestion": false
}

2. {
  "code": "def reverse_string(s): return s[::-1]",
  "isCodingQuestion": true
}

Uses examples
Much higher accuracy
Widely used in production systems

Use Few-Shot when:

You want consistency
You need better control over answers

4. Chain-of-Thought (CoT) Prompting:

This is my personal favorite 💡

Chain-of-Thought prompting forces the model to think step-by-step before answering.

Instead of jumping straight to the answer, the model:

Analyzes the problem
Plans the solution
Executes step by step
Produces the final output

Example System Prompt:

import json 
from openai import OpenAI

client = OpenAI("API_KEY")

# Chain-of-Thought prompt: asking model to think step by step
SYSTEM_PROMPT = """
You are a helpful coding assistant. When solving problems, think step by step and explain your reasoning clearly.

Follow this format:
1. Understand the problem
2. Break it down into steps
3. Write the solution
4. Explain the approach

Always provide code in JSON format:
{
  "thinking": "Your step-by-step reasoning",
  "code": "Your code solution",
  "explanation": "Brief explanation of the solution"
}
"""

def ask_model_with_cot(user_message: str) -> str:
    """
    Sends a Chain-of-Thought style prompt to the LLM and returns the response.
    """
    response = client.chat.completions.create(
        model="gemini-3-flash-preview",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": user_message}
        ]
    )
    return response.choices[0].message.content


# Example:
  response = ask_model_with_cot("How do I reverse a string in Python?")
  result = json.loads(response.choices[0].message.content) 

  print("Thinking:", result["thinking"])                                                                                                              
  print("\nCode:")                                                                                                                                    
  print(result["code"])                                                                                                                               
  print("\nExplanation:", result["explanation"])  


#Output Looks:

Thinking: To reverse a string in Python, the most efficient and common method is using string slicing. Since strings are immutable, we create a new string that traverses the original string from the last character to the first. 

1. **Slicing Method**: Use the syntax `[start:stop:step]`. By setting the step to `-1`, Python moves through the string backwards.
2. **Built-in Function**: Use `reversed()` which returns an iterator, and then `join()` it back into a string.
3. **Looping**: Manually build a new string by prepending characters (though this is less efficient).

Code:
# Method 1: String Slicing (Recommended)
original_string = "Hello World"
reversed_string = original_string[::-1]
print(f"Slicing method: {reversed_string}")

# Method 2: reversed() and join()
reversed_string_2 = "".join(reversed(original_string))
print(f"Reversed function method: {reversed_string_2}")

Explanation: The most Pythonic way is `string[::-1]`. This slicing notation starts at the end of the string and moves toward the beginning with a step of -1. Alternatively, `"".join(reversed(string))` uses a built-in function to iterate backwards and joins the characters into a new string.

Why CoT Is Powerful
Instead of this: "Here’s the answer."

You get this: “Let me think… first I’ll analyze the problem… then plan… then solve…”

More human-like
Higher reasoning accuracy
Used in GPT-4o, DeepSeek, O3 models, etc.

5. Automating Chain-of-Thought(Agent Style Reasoning):

In the CoT part, we manually asked the model to “think step by step.”
That works — but it’s not scalable.

The real problem is this:
You can’t keep adding prompts again and again by hand.

So the next step is obvious… automate it.

Instead of treating the LLM like a one-shot chatbot, we turn it into a small reasoning engine that plans, thinks, and then answers.

The Core Idea

We give the model a fixed reasoning framework and tell it:

Always analyze first
Always plan before answering
Always justify the solution

**Step 1: Create an Auto-Reasoning System Prompt

Here’s Automated Chain-of-Thought prompt:

SYSTEM_PROMPT = """
You are an intelligent reasoning engine. For any problem given, follow this automatic reasoning process:

REASONING FRAMEWORK:
1. Problem Analysis: Break down the problem into components
2. Information Gathering: Identify what information is needed
3. Hypothesis Formation: Generate potential solutions
4. Evaluation: Compare solutions against criteria
5. Conclusion: Recommend the best approach

RESPONSE FORMAT:
{
    "problem": "restate the problem",
    "analysis": {
        "key_components": ["component 1", "component 2"],
        "constraints": ["constraint 1"],
        "requirements": ["requirement 1"]
    },
    "reasoning_steps": [
        {
            "step": 1,
            "action": "what to consider",
            "finding": "what we discover"
        }
    ],
    "solution": {
        "approach": "chosen approach",
        "code": "implementation",
        "reasoning": "why this approach is best"
    },
    "alternatives": [
        {
            "approach": "alternative approach",
            "pros": ["pro 1"],
            "cons": ["con 1"]
        }
    ]
}

IMPORTANT: Always show your reasoning explicitly. Do not jump to conclusions.
"""

**Step 2: Call the Model Using the Python Code

Now plug this prompt into program:

from openai import OpenAI

client = OpenAI("API_KEY")

response = client.chat.completions.create(
    model="gemini-3-flash-preview",
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": "How do I optimize React Native App?"}
    ]
)

print(response.choices[0].message.content)

What’s Happening Internally:

Restates the problem
Breaks it into parts
Generates multiple solution ideas
Evaluates them
Then gives the final answer

With this pattern, your LLM now:

Thinks before answering
Plans instead of guessing
Evaluates instead of reacting

Final Thoughts

Prompting isn’t about clever wording.
It’s about designing thought processes.

When you move from “Give me the answer” to
“Here’s how to analyze, reason, and decide,”
you unlock a completely different level of output quality.

Manual Chain-of-Thought is a great start.
But automated reasoning is where real systems are built.

So next time you write a prompt, don’t ask:

❌ What’s the answer?

Ask instead:

✅ How should the model think?

Because the future of AI isn’t better responses —
it’s better reasoning.

How Tokenization, Embeddings & Attention Work in LLMs (Part 2)

Prabhakar — Mon, 26 Jan 2026 16:14:10 +0000

In Part 1, we learned what an LLM is and how it generates text.
Now let’s go deeper into how models like ChatGPT actually process language internally.

This article covers:

What a token really is
How tokenization works
Encoding & decoding with Python
Vector embeddings
Positional encoding
Self-attention & multi-head attention

1. What Is a Token?

A token is a piece of text converted into a number that the model understands.

Example:

A → 1  
B → 2  
C → 3

So if you type:
B D E → it becomes → 2 4 5

LLMs don’t understand words.
They understand numbers.

This process of converting text → numbers is called tokenization.

2. What Is Tokenization?

Tokenization means:

Converting user input into a sequence of numbers that the model can process.

Workflow:

Text → Tokens → Model → Tokens → Text

Example:

Input:

"Hey there, my name is Piyush"

Internally becomes:

[20264, 1428, 225216, 3274, ...]

These numbers go into the transformer, which predicts the next token again and again.

3. Encoding & Decoding Tokens in Python

Using the tiktoken library:

import tiktoken

encoder = tiktoken.encoding_for_model("gpt-4o")

text = "Hey there, my name is Prabhas Kumar"
tokens = encoder.encode(text)

print(tokens)

decoded = encoder.decode(tokens)
print(decoded)

What happens:

encode() → converts text → tokens
decode() → converts tokens → readable text

This is exactly how ChatGPT works internally.

4. Vector Embeddings – Giving Words Meaning

Tokens alone are just numbers.
Embeddings give them meaning.

An embedding is a vector (list of numbers) that represents the semantic meaning of a word.

Example idea:

Dog and Cat → close together
Paris and India → close together
Eiffel Tower and India Gate → close together

Words with similar meaning are placed near each other in vector space.

That’s how LLMs understand relationships like:

Paris → Eiffel Tower  
India → Taj Mahal

This is called semantic similarity.

5. Positional Encoding – Order Matters

Consider:

"Dog ate cat"
"Cat ate dog"

Same words.
Different meaning.

Embeddings alone don’t know position.
So the model adds positional encoding.

Positional encoding tells the model:

This word is first
This word is second
This word is third

So the model understands order and structure.

6. Self-Attention – Words Talking to Each Other

Self-attention lets tokens influence each other.

Example:

"river bank"
"ICICI bank"

Same word: bank
Different meaning.

Self-attention allows:

"river" → changes meaning of "bank"
"ICICI" → changes meaning of "bank"

So context decides meaning.

7. Multi-Head Attention – Looking at Many Angles

Multi-head attention means the model looks at:

Meaning
Position
Context
Relationship

At the same time.

Like a human observing many things at once.

This gives the model a deep understanding of the sentence.

8. Final Flow of an LLM

User enters text

Tokenization → numbers

Embeddings → meaning

Positional encoding → order

Self + Multi-head attention → context

Linear + Softmax → probability of next token

Decode → readable output

Final Thoughts

LLMs don’t know language.
They predict tokens based on probability and patterns.

Yet the result feels intelligent because:

Tokens carry meaning (embeddings)
Order is preserved (positional encoding)
Context is understood (attention)

And that’s the magic behind ChatGPT.

How Tokenization, Embeddings & Attention Work in LLMs (Part 2)

Prabhakar — Sat, 24 Jan 2026 18:33:01 +0000

In Part 1, we learned what an LLM is and how it generates text.
Now let’s go deeper into how models like ChatGPT actually process language internally.

This article covers:

What a token really is
How tokenization works
Encoding & decoding with Python
Vector embeddings
Positional encoding
Self-attention & multi-head attention

1. What Is a Token?

A token is a piece of text converted into a number that the model understands.

Example:

A → 1  
B → 2  
C → 3

So if you type:
B D E → it becomes → 2 4 5

LLMs don’t understand words.
They understand numbers.

This process of converting text → numbers is called tokenization.

2. What Is Tokenization?

Tokenization means:

Converting user input into a sequence of numbers that the model can process.

Workflow:

Text → Tokens → Model → Tokens → Text

Example:

Input:

"Hey there, my name is Piyush"

Internally becomes:

[20264, 1428, 225216, 3274, ...]

These numbers go into the transformer, which predicts the next token again and again.

👉Note: Every model has its own mechanism for generating tokens.

3. Encoding & Decoding Tokens in Python

Using the tiktoken library:

import tiktoken

encoder = tiktoken.encoding_for_model("gpt-4o")

text = "Hey there, my name is Prabhas Kumar"
tokens = encoder.encode(text)

print(tokens)

decoded = encoder.decode(tokens)
print(decoded)

What happens:

encode() → converts text → tokens
decode() → converts tokens → readable text

This is exactly how ChatGPT works internally.

4. Vector Embeddings – Giving Words Meaning

Tokens alone are just numbers.
Embeddings give them meaning.

An embedding is a vector (list of numbers) that represents the semantic meaning of a word.

Example idea:

Dog and Cat → close together
Paris and India → close together
Eiffel Tower and India Gate → close together

Words with similar meaning are placed near each other in vector space.

That’s how LLMs understand relationships like:

Paris → Eiffel Tower  
India → Taj Mahal

This is called semantic similarity.

5. Positional Encoding – Order Matters

Consider:

"Dog ate cat"
"Cat ate dog"

Same words.
Different meaning.

Embeddings alone don’t know position.
So the model adds positional encoding.

Positional encoding tells the model:

This word is first
This word is second
This word is third

So the model understands order and structure.

6. Self-Attention – Words Talking to Each Other

Self-attention lets tokens influence each other.

Example:

"river bank"
"ICICI bank"

Same word: bank
Different meaning.

Self-attention allows:

"river" → changes meaning of "bank"
"ICICI" → changes meaning of "bank"

So context decides meaning.

7. Multi-Head Attention – Looking at Many Angles

Multi-head attention means the model looks at:

Meaning
Position
Context
Relationship

At the same time.

Like a human observing many things at once.

This gives the model a deep understanding of the sentence.

8. Final Flow of an LLM

User enters text

Tokenization → numbers

Embeddings → meaning

Positional encoding → order

Self + Multi-head attention → context

Linear + Softmax → probability of next token

Decode → readable output

Final Thoughts

LLMs don’t know language.
They predict tokens based on probability and patterns.

Yet the result feels intelligent because:

Tokens carry meaning (embeddings)
Order is preserved (positional encoding)
Context is understood (attention)

And that’s the magic behind ChatGPT.

What Is an LLM? How ChatGPT, GPT & AI Language Models Really Work (Part 1)

Prabhakar — Sun, 18 Jan 2026 17:12:28 +0000

How Large Language Models (LLMs) Work — A Beginner-Friendly Guide

Learn how Large Language Models (LLMs) like ChatGPT work. Understand tokens, GPT, transformers, and how AI generates human-like text in simple terms.

If you’ve used ChatGPT, Gemini, or Claude, you’ve already interacted with a Large Language Model (LLM).

It feels like chatting with a human, but behind the scenes, it’s all math, data, tokens, and probabilities.

In this article, you will learn:

What an LLM is
How LLMs are trained
What tokens are and how they work
The meaning of GPT
How LLMs generate answers step by step

1. What Is an LLM?

LLM = Large Language Model

An LLM is an AI system trained to:

Understand human language
Generate human-like responses

Example:

“Explain recursion like I’m 10.”

LLMs allow humans to talk to computers using natural language instead of code, making it easier for anyone to interact with AI systems without learning programming.

2. How Are LLMs Trained?

LLMs are trained on massive datasets, including:

Books
Blogs
Articles
Code repositories
Web content

Unlike databases, LLMs don’t store facts verbatim.

Instead, they learn patterns, relationships, and probabilities in language.

Think of it like humans learning a language — the more you read, the better you understand how sentences are structured and how to respond appropriately.

3. Tokens: How AI Understands Text

Computers don’t understand words — they understand numbers.

When you type:

“Hello world”

It might become something like:

[15496, 995]

This process is called tokenization, and it’s how LLMs convert text into something they can process.

Workflow of AI Text Generation:

Text → Tokens → Model → Tokens → Text

Tokenization: Converts text into numbers (tokens).
Model processing: Predicts the next token based on input and learned patterns.
Detokenization: Converts the output tokens back into human-readable text.

4. Input Tokens vs Output Tokens

Input Tokens: The message or question you send to the AI.
Output Tokens: The AI’s generated response.

The AI predicts one token at a time and continues until a complete response is generated — similar to an advanced autocomplete system.

5. What Does GPT Mean?

GPT = Generative Pretrained Transformer

Breaking it down:

5.1 Generative

LLMs generate responses on the fly rather than searching the web.

Example:

You: “Call me Captain Dev”

LLM: “Sure, Captain Dev!”

This response is original, created by the AI based on patterns it learned — it didn’t exist anywhere before.

5.2 Pretrained

Before interacting with users, LLMs are trained on large datasets.

Like humans, they learn first, then generate content. This pretraining allows them to answer questions accurately and contextually.

5.3 Transformer

The transformer is the neural network architecture powering modern LLMs.

It allows the model to process context effectively and predict the next token accurately.

All major LLMs use transformer-based architectures:

GPT (OpenAI)
Gemini (Google)
Claude (Anthropic)
Mistral

In short, all these models are Generative + Pretrained + Transformers in nature.

6. How LLMs Generate Answers Step by Step

Think of an LLM as a super-smart autocomplete system:

You type: “The sky is…”
The model predicts: “blue”
Then predicts the next token: “today”
It continues predicting one token at a time until the full response is generated

This token-by-token generation allows LLMs to create long, coherent responses based on context.

7. Real-World Example

Let’s say you ask an LLM:

“Write a short introduction about yourself for a portfolio website.”

The process happens like this:

Input: The AI receives your text (input tokens).
Prediction: The model predicts the next word or token based on pretraining and context.
Iteration: It continues token by token until the response is complete.
Output: Detokenization converts the tokens into readable text for you to copy and use.

This is why AI can generate blog posts, code snippets, summaries, and more instantly.

8. Final Thoughts

LLMs are transforming how humans interact with machines.

Instead of humans learning programming languages, machines are learning human language.
LLMs are tools for communication, automation, and creative generation.
This is just the beginning of what AI can do.

With a better understanding of tokens, GPT, and transformers, you can now appreciate how AI generates intelligent, human-like responses.

Next in the Series:

Deep Dive into Tokens, Embeddings, and Vector Search in LLMs — Stay tuned for the next article!