Forem: Rahul

Beginner’s Guide to Writing AI Prompts That Work

Rahul — Wed, 25 Mar 2026 13:13:25 +0000

🧠 Stop Asking AI Bad Questions: The Prompting Playbook That Doubles Your Results

Most people use AI like a search engine. The ones getting extraordinary results treat it like a brilliant colleague — and they brief it accordingly.

Reading time: ~7 minutes | Audience: Anyone who uses AI regularly

You've used AI. You've probably been underwhelmed at least once. You typed something reasonable, got something generic back, and quietly assumed the technology just wasn't there yet.

Here's the uncomfortable truth: the technology was there. The prompt wasn't.

The gap between a mediocre AI output and one that genuinely impresses isn't the model — it's almost always the brief. This guide gives you the exact framework used by the people consistently getting remarkable results, plus deep playbooks for the three most common domains where AI gets used every single day.

Part 1 — The Anatomy of a Great Prompt

Every high-performing prompt is built from five ingredients. You won't always need all five — a simple question needs no ceremony. But when a prompt underperforms, the missing piece is almost always one of these.

The Five Ingredients

Ingredient	What It Does	Example
Role	Sets vocabulary, depth, and assumptions	"Act as a senior UX researcher"
Context	Tells it the situation and goal	"I'm presenting this to a non-technical board"
Format	Defines the shape of the output	"Respond with a markdown table"
Constraints	Sets the guardrails	"Max 150 words. No jargon. No bullet points."
Examples	Shows what good looks like	"Here's a paragraph I wrote — match this tone"

The formula:

Role + Context + Format + Constraints + Examples = Exceptional Output

The single biggest upgrade most people can make is simply replacing vague instructions with specific ones.

❌ Vague vs ✅ Specific

Vague:

Summarize this data for me.

Specific:

Summarize this sales data in 3 bullet points for a non-technical CEO.
Focus on month-over-month trends and flag one key risk.
Avoid jargon. Each bullet should be one sentence maximum.

Same task. Completely different output.

📊 How Output Quality Scales With Prompt Detail

The more complete your prompt, the better your result — consistently, across every use case.

1 word only        ████░░░░░░░░░░  ~15% satisfying
1 sentence         █████████░░░░░  ~35% satisfying
+ Context added    █████████████░  ~58% satisfying
+ Format added     ████████████████░  ~74% satisfying
All 5 ingredients  ████████████████████  ~93% satisfying

Estimated satisfaction rate based on prompt completeness

5 Universal Rules That Improve Any Prompt

These work regardless of domain, tool, or task.

1. Use chain-of-thought
Add "think step by step before answering." This single phrase dramatically improves accuracy on complex tasks because it forces the model to reason rather than pattern-match.

2. Assign a persona
"You are an expert in X with 15 years of experience" primes the model to skip surface-level explanations and make expert-grade assumptions.

3. Iterate rather than restart
The best results come from a conversation, not a single message. Start broad, then refine: "Now shorten this to 150 words" or "Rewrite the opening to be more direct."

4. Declare your output format explicitly
"Respond only with a JSON object" or "Write in plain paragraphs — no bullet points" eliminates ambiguity and saves editing time.

5. State what to avoid
"Do not use passive voice," "Avoid recommending paid tools," and "Do not explain what you are about to do — just do it" are negative constraints that sharpen output significantly.

Part 2 — Prompting for Data Analysis

The dominant business AI use case worldwide

From startup founders parsing monthly revenue to enterprise analysts crunching millions of rows, data analysis is the most common professional AI task in the world today. The stakes are high: a misread data prompt doesn't just produce a weak paragraph — it produces a wrong conclusion that someone might act on.

The key challenge: AI cannot see your spreadsheet unless you describe it. You must hand the model your schema — column names, data types, and a few sample rows — before asking any question. Skipping this step is the single most common mistake in data prompting.

Why Most Data Prompts Fail

Most weak data prompts share three problems:

They describe the goal but not the data structure
They don't specify who needs to read the output
They never ask the model to flag its own assumptions

Those three gaps turn a potentially useful analysis into something confidently wrong.

Tips for Data Prompting

T1 — Lead with your schema
Before asking anything, describe your columns: name, type, and possible values. Paste two or three sample rows. This gives the model a working mental model of your actual data.

T2 — Specify the audience for the insight
"Explain this to a non-technical CEO" produces a narrative summary. "Write this for a data scientist reviewing methodology" produces something far more technical. Same data, completely different output.

T3 — Ask it to explain its reasoning first
"Before answering, tell me which metrics you are using and why" catches faulty assumptions before they become errors in your report.

T4 — Request explicit caveats
End every analysis prompt with: "List any assumptions you are making and any data quality issues I should verify." This turns a confident-sounding answer into a transparent, trustworthy one.

T5 — Layer your questions
Start with "Describe the distribution of [column]" before jumping to "Find the root cause of the Q3 revenue dip." Build shared understanding step by step.

🧪 World-Class Data Prompt Example

Role:    Act as a senior business intelligence analyst.

Data:    CSV with these columns:
         order_id (string), customer_id (string),
         region (NA / EU / APAC), product_sku (string),
         revenue_usd (float), order_date (YYYY-MM-DD),
         churn_flag (0 or 1)

Task:    Identify which region + product_sku combinations
         carry the highest churn risk.
         Rank them and explain the pattern driving each one.

Output:  Python code using pandas.
         Include a ranked summary table and a bar chart
         with matplotlib. Comment every step clearly.

Caveats: Do not assume anything about missing values.
         List every assumption you make before writing code.

Part 3 — Prompting for Software Development

The highest-volume AI use case globally

Developers are the most prolific AI users on the planet. AI has become the default co-pilot for writing boilerplate, debugging errors, reviewing pull requests, and scaffolding new features. Yet most engineers still leave enormous value on the table by prompting too vaguely.

The core insight: context is everything. The same function request written without a tech stack description produces generic, often unusable code. Written with a precise environment description, it produces something you can paste directly into production.

The Context Stack Every Code Prompt Needs

Think of briefing the AI like onboarding a contractor. Before writing a line of code, a good contractor asks:

What stack are we on?
What conventions do we follow?
What does the existing code look like?

Your prompt should answer all three before the model starts writing.

Tips for Code Prompting

T1 — Always name the language and version
"Python 3.11," "TypeScript 5.3," "Go 1.22" — never assume the model will pick what you need. Version matters especially for Python, where async patterns and type hints differ significantly between releases.

T2 — Paste the code you want improved
Never describe existing code when you can show it. Paste the function or module and say "refactor this to..." rather than "write a function that..." Real code beats descriptions every time.

T3 — State your constraints upfront
"No external libraries," "must run in a browser," "needs to handle 10 million rows without loading all into memory" — these completely change what good code looks like.

T4 — Ask for tests alongside the code
"Write the function AND a pytest test suite covering the happy path, edge cases, and error states" doubles your value per prompt and surfaces hidden logic assumptions before you ship them.

T5 — Use the error-first technique for debugging
Paste the exact error message, the relevant code block, and your environment details. "It doesn't work" wastes a turn. A full stack trace with context gets you a precise fix in one shot.

🧪 World-Class Coding Prompt Example

Stack:     Python 3.11, FastAPI, SQLAlchemy 2.0, PostgreSQL

Task:      Build a REST endpoint: POST /users/{id}/deactivate
           Soft-delete the user by setting is_active = False
           and deactivated_at = now().
           Then dispatch an async confirmation email
           via a Celery task.

Rules:     - Must be idempotent (safe to call twice)
           - Return 404 if user not found
           - Return 409 if user is already inactive
           - Use ORM only — no raw SQL
           - Follow snake_case naming throughout

Also:      Write a pytest suite covering the happy path,
           the already-inactive case, and the 404 case.

Part 4 — Prompting for Creative & Professional Writing

The most personal — and most misused — AI use case

Blog posts, marketing copy, cover letters, reports, social media, emails — writing is where AI gets used by the widest range of people. It's also where the gap between a mediocre prompt and a brilliant one is most visible.

Generic AI writing is identifiable from a mile away. Writing produced from a carefully crafted prompt is indistinguishable from the real thing.

The core challenge: AI defaults to a confident, neutral, mildly formal register. If that is not your voice, you must describe what you actually want — across three dimensions: formality, energy, and personality. Vague tone instructions like "make it friendly" change almost nothing.

Voice Is the Hardest Thing to Get Right — and the Most Important

The fastest way to transfer your voice to AI is not to describe it — it's to demonstrate it. Paste a paragraph you have already written and say "match this tone exactly." That single move eliminates more back-and-forth than any amount of adjective-based instruction.

Tips for Writing Prompts

T1 — Define the reader, not just the topic
"A burnt-out product manager who reads on their commute and has no patience for waffle" is a far richer brief than "a busy professional." The more specific your reader, the more targeted the writing.

T2 — Name the emotion you want to create
"Leave the reader feeling quietly motivated, not hyped" or "aim for wry self-awareness, not earnest inspiration" is the kind of direction that separates good copy from great copy.

T3 — Ban the clichés explicitly
List phrases to avoid: "dive into," "game-changer," "in today's fast-paced world," "leverage," "unlock your potential," "journey." AI reaches for these by default. You have to close the door deliberately.

T4 — Give it a structural scaffold
Tell it exactly how you want the piece to move: "Open with a counter-intuitive claim. Spend the middle on one concrete story. Close with a single actionable takeaway." Structure beats length instructions every time.

T5 — Ask for three versions
"Give me three different opening paragraphs with three different emotional tones" costs nothing extra and gives you real creative options instead of forcing you to accept or reject a single draft.

🧪 World-Class Writing Prompt Example

Goal:      Write a 600-word LinkedIn article on why most
           startup founders underinvest in operations.

Reader:    Series A founder, engineering background, 28–35.
           Reads fast, hates jargon, has heard every
           startup cliché and is immune to them.

Voice:     Direct, slightly wry, intellectually honest.
           Short paragraphs. Conversational but precise.
           No motivational-poster energy whatsoever.

Structure: 1. Hook: a counter-intuitive claim (2 sentences)
           2. The real problem — not the obvious one
           3. One concrete mini-story
           4. Three specific fixes
           5. Low-key, non-salesy close

Avoid:     "dive into", "game-changer", "journey",
           passive voice, any sentence over 25 words.

The Takeaway — Prompt Like You Mean It

The most common mistake people make with AI is treating it like a search engine: fire a query, read the result, move on. But AI is something fundamentally different — it's a collaborator that gets sharper the more context you give it, and better with every follow-up you send.

You now have the full framework:

✅ The five-part anatomy that structures any prompt
✅ Five universal rules that improve every request
✅ Deep playbooks for data analysis, software development, and creative writing

"You don't need to be a prompt engineer. You just need to be a clear thinker who communicates deliberately. That was always the skill worth having."

What separates the people getting remarkable results from those getting mediocre ones isn't access to a better model. It's the habit of investing fifteen extra seconds in a more thoughtful prompt.

Start with your next one.

Rahul

Turning coffee into bugs

If this helped you, drop a ❤️ and follow for more practical guides — no hype, just things that actually work.

Go Slices: Why Your Function Isn't Changing What You Think It Is

Rahul — Sat, 21 Mar 2026 10:02:04 +0000

5 min read · Beginner-friendly · Real code you can paste into Go Playground

The bug that confuses every Go beginner

You pass your slice to a function. The function changes some values. You print the slice back in main... and some changes are there, some aren't.

Sound familiar? This article explains exactly why — with diagrams, not walls of text.

Our data — a fleet of vehicles

Two structs, one slice. Everything in this article uses these types.

type VehicleType struct {
    TwoWheeler, ThreeWheeler, FourWheeler bool
}

type Vehicle struct {
    Model, Color string
    Type         VehicleType  // nested by value — not a pointer
}

type Fleet []Vehicle

Fill it with two vehicles:

fleet := Fleet{
    {Model: "Bike", Color: "Red",  Type: VehicleType{TwoWheeler:  true}},
    {Model: "Car",  Color: "Blue", Type: VehicleType{FourWheeler: true}},
}

What is a slice? (the sticky note model)

Before anything else, burn this mental model in — a slice variable is just a 3-field sticky note. The real data lives on the heap.

When you pass fleet to a function, Go copies the sticky note — not the parking lot.

Pass by value — a photocopy of the sticky note

The function gets its own header copy. Both copies point at the same backing array.

func byValue(fleet Fleet) {
    fleet[0].Color = "Green"         // ✅ writes to shared heap — caller SEES it
    fleet[0].Type.TwoWheeler = false  // ✅ nested struct is on the heap too
    fleet = append(fleet, Vehicle{})  // ❌ updates ONLY the function's copy of len
}

What the caller sees after byValue(fleet):

Action	Visible to caller?
`fleet[0].Color` → "Green"	✅ Yes
`fleet[0].Type.TwoWheeler` → false	✅ Yes
`len(fleet)` → 3 from append	❌ No — still 2

💡 Seems quite easy: Repainting a car already in the lot? Everyone sees it. Driving a new car into YOUR copy of the address? The owner's map still shows 2 cars.

Pass by reference — handing over the key

Pass *Fleet so the function can update the caller's header — including length.

func byRef(fleet *Fleet) {
    (*fleet)[0].Color = "Yellow"       // ✅ visible to caller
    *fleet = append(*fleet, Vehicle{}) // ✅ len change visible to caller too
}

// call it:
byRef(&fleet)

What the caller sees after byRef(&fleet):

Action	Visible to caller?
`fleet[0].Color` → "Yellow"	✅ Yes
`len(fleet)` → 3 from append	✅ Yes
New vehicle at `fleet[2]`	✅ Yes

🔑 As simple as that: You handed the function the actual key to the parking office. It can repaint cars AND add new bays — and you'll see all of it.

Deep clone — two completely separate parking lots

Need zero shared state? Use copy() to build a brand-new backing array.

clone := make(Fleet, len(fleet))
copy(clone, fleet)           // new backing array at a new address
clone[0].Color = "Purple"    // original fleet untouched ✅

🧬 When to use this: Sorting or filtering for display, transforming data for an API response, or any time changes must not affect the source slice.

Quick reference

Action	Pass by Value	Pass by Reference
`fleet[0].Color = ...`	✅ Caller sees it	✅ Caller sees it
`fleet[0].Type.X = ...`	✅ Caller sees it	✅ Caller sees it
`append(fleet, vehicle)`	❌ NOT visible	✅ Caller sees it

3 rules — commit these to memory

Rule 1 ✅ — Mutate existing element → always visible, value or pointer.

Rule 2 ⚠️ — append → only visible when you pass *Fleet (pointer).

Rule 3 🧬 — Total isolation → use copy() for a brand-new backing array.

Full runnable example

Paste this into Go Playground and run it:

package main

import "fmt"

type VehicleType struct {
    TwoWheeler, ThreeWheeler, FourWheeler bool
}
type Vehicle struct {
    Model, Color string
    Type         VehicleType
}
type Fleet []Vehicle

func byValue(f Fleet) {
    f[0].Color = "Green"      // ✅ visible to caller
    f = append(f, Vehicle{})  // ❌ NOT visible to caller
}

func byRef(f *Fleet) {
    (*f)[0].Color = "Yellow"   // ✅ visible to caller
    *f = append(*f, Vehicle{}) // ✅ visible to caller
}

func main() {
    fleet := Fleet{
        {Model: "Bike", Color: "Red",  Type: VehicleType{TwoWheeler: true}},
        {Model: "Car",  Color: "Blue", Type: VehicleType{FourWheeler: true}},
    }

    byValue(fleet)
    fmt.Println(fleet[0].Color, len(fleet)) // Green 2

    byRef(&fleet)
    fmt.Println(fleet[0].Color, len(fleet)) // Yellow 3
}

What about the nested VehicleType?

Because VehicleType is embedded by value inside Vehicle (not a pointer), it lives contiguously in memory with the rest of the struct. No special rules — it copies and mutates exactly like any other field.

If it were a pointer (Type *VehicleType), that would be a different story — but that's a topic for another article.

Rahul

Turning coffee into bugs

My first blog, found this useful? Let me know in comments.

Forem: Rahul

Beginner’s Guide to Writing AI Prompts That Work

🧠 Stop Asking AI Bad Questions: The Prompting Playbook That Doubles Your Results

Part 1 — The Anatomy of a Great Prompt

The Five Ingredients

❌ Vague vs ✅ Specific

📊 How Output Quality Scales With Prompt Detail

5 Universal Rules That Improve Any Prompt

Part 2 — Prompting for Data Analysis

Why Most Data Prompts Fail

Tips for Data Prompting

🧪 World-Class Data Prompt Example

Part 3 — Prompting for Software Development

The Context Stack Every Code Prompt Needs

Tips for Code Prompting

🧪 World-Class Coding Prompt Example

Part 4 — Prompting for Creative & Professional Writing

Voice Is the Hardest Thing to Get Right — and the Most Important

Tips for Writing Prompts

🧪 World-Class Writing Prompt Example

The Takeaway — Prompt Like You Mean It

Rahul

Tags

Go Slices: Why Your Function Isn't Changing What You Think It Is

The bug that confuses every Go beginner

Our data — a fleet of vehicles

What is a slice? (the sticky note model)

Pass by value — a photocopy of the sticky note

Pass by reference — handing over the key

Deep clone — two completely separate parking lots

Quick reference

3 rules — commit these to memory

Full runnable example

What about the nested VehicleType?

Rahul