From Full Stack to AI: Advanced Prompt Engineering Techniques

When you come from a Full Stack background, AI feels familiar and unfamiliar at the same time. You already know APIs, requests, responses, and JSON. What changes is how you talk to the model. Prompt engineering is simply learning how to give clear instructions so the model behaves the way you want. This article is a learning note I wish I had when I started.

---

What is Prompt Engineering

Prompt engineering means writing instructions for a language model so it produces useful and predictable results.
A prompt is just text. But how you structure that text decides whether the model gives a clean answer or something confusing.

Think of it like calling a backend API. If you send bad input, you get bad output.

1. Prompt Fundamentals: Encoding Instructions for LLMs

What it is

This is about clearly telling the model what it should do and what it should not do.
You usually do this using a system prompt.

Simple idea

System prompt is like setting rules before the conversation starts.

Example in Python

from dotenv import load_dotenv
import os
from openai import OpenAI

load_dotenv()

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

SYSTEM_PROMPT = (
    "You only answer coding related questions. "
    "If the question is not about coding, say sorry."
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": "Write a Python function to add two numbers"}
    ]
)

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

Output

def add(a, b):
    return a + b

Explanation

The system prompt restricts behavior. The model follows it and answers only coding questions.

2. Prompting Types: Zero Shot, One Shot, Few Shot

Zero Shot Prompting

What it is

You ask a question directly without giving any example.

Example

prompt = "Translate the word hello to Hindi"

Output

नमस्ते

Explanation

The model already knows enough to answer without examples.

One Shot Prompting

What it is

You give exactly one example before asking your question.

Example

messages = [
    {"role": "user", "content": "Translate hello to French"},
    {"role": "assistant", "content": "Bonjour"},
    {"role": "user", "content": "Translate hello to Hindi"}
]

Output

नमस्ते

Explanation

The model learns the pattern from one example and applies it.

Few Shot Prompting

What it is

You give multiple examples so the model understands the format and context better.

Example

messages = [
    {"role": "user", "content": "Add two numbers in Python"},
    {"role": "assistant", "content": "def add(a,b): return a+b"},
    {"role": "user", "content": "Multiply two numbers in Python"}
]

Output

def multiply(a, b):
    return a * b

Explanation

More examples reduce ambiguity and improve consistency.

3. One Shot Prompting for Deterministic Inference

What it is

You want the same output every time. One example guides the model strongly.

Example

SYSTEM_PROMPT = "Always return output as JSON"

messages = [
    {"role": "system", "content": SYSTEM_PROMPT},
    {"role": "user", "content": "Add two numbers in Python"}
]

Output

{
  "code": "def add(a, b): return a + b"
}

Explanation

Clear rules plus one format expectation lead to stable output.

4. Few Shot Prompting for Contextual Generalization

What it is

You help the model understand both intent and structure.

Example using structured rules

SYSTEM_PROMPT = """
Only answer coding questions.
Return JSON output.

Examples:
Q: What is a+b?
A: {"code": null, "isCoding": false}

Q: Write Python add function
A: {"code": "def add(a,b): return a+b", "isCoding": true}
"""

Output

{
  "code": "function add(arr){ return arr.reduce((a,b)=>a+b,0)}",
  "isCoding": true
}

Explanation

The model generalizes from examples and keeps structure intact.

5. Structured Outputs with Few Shot Prompting

What it is

You force a fixed output format like JSON.

Example

SYSTEM_PROMPT = """
Return output strictly in JSON:
{ "language": "", "code": "" }
"""

user = "Write a JS function to add two numbers"

Output

{
  "language": "JavaScript",
  "code": "function add(a,b){ return a+b }"
}

Explanation

This is useful when integrating with frontend or backend systems.

6. Chain of Thought for Reasoning

What it is

The model explains steps before giving the final answer.

Simple Example

SYSTEM_PROMPT = """
Return JSON:
{ "step": "PLAN or OUTPUT", "content": "" }
"""

Output

{ "step": "PLAN", "content": "We need to add two numbers" }
{ "step": "OUTPUT", "content": "def add(a,b): return a+b" }

Explanation

You see how the model reasons. This helps in debugging logic.

7. Auto Chain of Thought

What it is

The model generates its own reasoning steps automatically without examples.

Example

prompt = "Solve: 10 * (2 + 3)"

Output

First calculate inside brackets.
2 + 3 = 5
Then multiply.
10 * 5 = 50

Explanation

The model decides when reasoning is needed.

8. Persona Based Prompting

What it is

You tell the model who it is and how it should behave.

Example

SYSTEM_PROMPT = """
You are Payal Kumari.
You are a Full Stack developer learning GenAI.
You explain things simply.
"""

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": "Explain list comprehension"}
    ]
)

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

Output

List comprehension is a short way to create lists in Python using a loop in one line.

Explanation

Persona controls tone, depth, and style of answers.

---

Closing Thoughts

Prompt engineering is not magic. It is clear thinking written as text.
If you understand APIs, contracts, and edge cases, you already have the mindset needed.

Start small. Test prompts. Break them. Fix them.
Strong foundations always beat shortcuts.

Documenting my Full Stack → AI journey, step by step.

By Payal Kumari