Prompting

Who This Is For

Anyone who uses AI tools and suspects they're not getting as much out of them as they could. You don't need a technical background. This guide covers the thinking, not just the techniques.

This is a 40-minute read. By the end, you'll understand how language models actually work (well enough to prompt them better), know the real reasons prompts fail, and have a practical toolkit for writing prompts that get consistent, useful results — whether you're using Claude, ChatGPT, or any other AI assistant.

Why Prompting Is a Real Skill

Most people start with AI the same way: they type something, get something back, feel vaguely underwhelmed, and conclude that either AI is overhyped or they're doing something wrong.

Usually, it's neither. It's a mismatch between what the model needs to do good work and what the person gave it.

Prompting is the interface between human intent and model output. When it's bad, you get generic, surface-level responses that feel like they could have been written by anyone. When it's good, you get outputs that feel almost unnervingly tailored — like the model understood what you were actually after, not just what you literally typed.

The skill gap between a casual AI user and a fluent one isn't knowledge of secret techniques. It's the ability to externalize what you want clearly, give the model enough context to work with, and iterate systematically when you don't get it right the first time.

It's a Pattern-Completion Machine

At the most fundamental level, a large language model does one thing: it predicts the next token given everything that came before it. It does this billions of times across billions of examples during training, until it develops a compressed statistical model of how language — and, implicitly, ideas and knowledge — fits together.

When you write a prompt, you're giving the model the beginning of a pattern, and it completes that pattern.

This has important implications. The model is trying to produce what plausibly comes after your prompt based on patterns in its training data. If your prompt is ambiguous, it will produce the most common completion for that ambiguous prompt — which may not be what you wanted. If your prompt is specific and well-framed, the model will try to complete that specific frame.

Context Is Everything

The model doesn't have persistent memory. Each conversation is a fresh context window — a sliding window of text that the model can "see" at once. Within a conversation, it remembers everything. Between conversations, it knows nothing about you unless you tell it.

More importantly: the model generates each response based on the entire contents of the context, not just your most recent message. This means:

• Earlier instructions stay in effect unless you override them
• Earlier examples shape later behavior
• A lot of context can help (more information to work with) or hurt (important instructions get "diluted")

Think of the context window as a document you're writing together. Everything in it shapes what comes next.

It's Trying to Be Helpful

Modern AI models are trained not just to predict text, but to predict helpful, harmless, honest responses to human requests. They're actively trying to understand your intent and give you something useful.

When a prompt fails, it's usually not the model being difficult — it's the model inferring a different intent than you had, or lacking the information it needs to do better.

It Doesn't Know What It Doesn't Know About You

The model was trained on internet text, books, code, and structured data. It knows an enormous amount in the abstract. It knows nothing specific about your project, your company, your preferences, your constraints, your audience, or your context — unless you tell it.

This is the single biggest source of generic, unhelpful outputs. The model produces a response that would be reasonable for someone with your request. But you're not someone — you're you, with specific context, specific standards, and a specific goal. Close that gap by providing that context.

The Six Failure Modes

Before learning what to do, it's useful to understand the failure modes. Most bad outputs trace back to these.

1. The Request Is Too Abstract

"Write a blog post about AI" is abstract. What kind of AI? For what audience? What tone — academic, conversational, edgy? What's the argument or angle? What length? Without answers to these, the model will produce something generic — because generic is the best answer to an abstract question.

The fix isn't to write a perfect prompt on the first try. It's to notice when you're being abstract and add specificity.

2. Missing Context

"Rewrite this to sound better" — better for whom? A technical engineering team? A marketing audience? A non-native English speaker who needs clarity? A C-suite audience who wants concision?

The model will guess. Its guess will be the most common interpretation, not necessarily yours. The fix is to provide the context that shapes what "better" means in your situation.

3. The Format Mismatch

You want a short email. The model writes a five-paragraph essay. You want a structured list. The model writes flowing prose. You want code with comments. The model writes code without any.

The model doesn't default to your preferred format — it defaults to whatever format is most common for that type of request in its training data. If you want a specific format, specify it.

4. Assuming the Model Knows Your Constraints

"Write a product description" — but you didn't mention it needs to be under 150 characters, avoid superlatives, and match the brand voice you've spent years developing.

The model can't see constraints you haven't stated. It will produce something plausible, not something constrained.

5. Conflating Complexity with Difficulty

Some things that feel complex are easy for the model. Some things that feel simple are hard. Models are excellent at generating text in a style, summarizing, translating, transforming formats, and reasoning through clearly-stated problems. They're worse at tasks that require persistent state, consistent counting, verifiable facts about recent events, or knowing when they don't know something.

6. Treating the First Output as Final

A prompt is a starting point, not a specification. The gap between "first draft" and "what you actually want" is normal — it's not a sign that prompting failed. Professional prompt writers expect to iterate. Most good results come from round two or three, after you've seen what the model produced and can sharpen your feedback.

The Core Components

There's no single template that works for everything, but most high-quality prompts share a set of components. You don't need all of them every time — the skill is knowing which matter for a given task.

Role and Context

Tell the model who it's acting as and what situation it's in.

"You are a senior product manager reviewing a feature proposal
from a junior PM. The proposal is ambitious but needs to be
grounded in user research and realistic timelines."

This isn't just roleplay for its own sake. It activates different knowledge and defaults. A response written as "a senior PM" will have different framing, priorities, and vocabulary than one written as a generic AI assistant.

The Task

State what you actually want the model to do. Be direct.

// Indirect and hedging
"I was wondering if you could maybe help me think through
some ideas for..."

// Direct and clear
"Generate five ideas for..."

The task statement should be specific enough that a thoughtful human could execute it. If you can't describe the task clearly to a person, you'll have trouble describing it to a model.

Relevant Information

Provide the raw material the model needs:

• The document, text, or data to work on
• Background context that shapes interpretation
• Examples of relevant outputs
• Constraints and requirements

More is usually better than less here, especially for tasks where domain knowledge matters. The model will use what it needs and ignore the rest more gracefully than most people expect.

Format Specifications

If you have a preference for how the output should look, say so explicitly:

"Respond in plain prose, no bullet points."
"Give me exactly three options, each two sentences max."
"Format your response as a JSON object with keys: title, summary, tags."
"Keep the total under 200 words."

Format instructions are cheap and highly effective. Use them.

Constraints and Things to Avoid

If there are patterns you want to prevent, name them.

"Don't use jargon. Avoid clichés like 'game-changing' or 'disruptive.'
Don't suggest anything that requires a login or account creation."

Negative constraints ("don't do X") work well when paired with the desired alternative. "Don't use bullet points — write in flowing prose" is better than just "don't use bullet points."

The Tone

Especially important for writing tasks. "Formal," "casual," "direct," "warm," "technical but accessible," "skeptical but fair" — the model will match a tone you describe. If you say nothing, it defaults to the neutral professional register common on the internet, which often isn't quite right for your context.

The Three Moves

Iteration isn't randomness. When your first output isn't right, there are three productive moves.

Move 1: Add Specificity

The most common fix. Your first prompt was probably too abstract. Look at what the model produced and ask: where did it have to guess? Where would more information have constrained the output usefully?

Move 2: Show an Example

When words fail, examples work. If you can't describe exactly what you want but you know it when you see it, find a comparable example and show it.

"Here's an example of the tone I'm going for:
[paste example]
Now rewrite the original in that style."

Examples are especially powerful for format, voice, and structure. A single good example often does more work than several paragraphs of description.

Move 3: Ask the Model to Reflect

If you're not sure why you're getting bad outputs, ask the model to reason through the task before executing.

"Before writing, tell me: what are the key tensions in this
brief? What would make this successful versus mediocre?"

Or have it audit its own work:

"Review what you just wrote. What's weak about it? What
assumptions did you make that might be wrong?"

Models are often surprisingly good at identifying their own shortcomings when explicitly asked. This is useful both for improving a specific output and for understanding what information you need to provide.

Context Design

Once you're comfortable with the basics, context design is where fluent prompters separate themselves. It's the art of shaping the entire context window, not just the most recent message.

System-Level Framing

In tools that allow it (Claude, ChatGPT with custom instructions, API calls with a system prompt), you can set persistent context that shapes every response in a conversation. Think of this as briefing the model before the task begins.

Good system-level framing includes:

• Your role and situation
• The model's role for this context
• Standing preferences (format, tone, things to avoid)
• Background context that will be relevant across the conversation

Front-Loading the Important Stuff

Models pay somewhat more attention to content at the beginning of the prompt than buried in the middle. If there's a constraint or instruction that's critical, don't bury it.

"Important: all outputs must be suitable for a PG audience
and avoid any reference to competitors by name."

Lead with what matters most.

Managing a Long Conversation

As conversations get longer, you'll sometimes notice quality drift — the model seems to forget earlier instructions or starts producing outputs that feel less calibrated. This is a real effect, not your imagination. Very long context windows can dilute the weight of earlier instructions.

The fix: periodically re-anchor. If you're deep in a long conversation and quality starts to slip, restate key constraints or preferences, or start a fresh conversation with the key context loaded upfront.

The "Outcome Context" Technique

For multi-step tasks especially, articulate the end-user or business outcome you're actually working toward — not just the immediate task.

// Instead of:
"Write three options for the email subject line."

// Try:
"I'm trying to get a 50% open rate from a cold list of
founders who've never heard of our company. Here are three
options for the subject line. Which would you change, and
what would you write instead?"

Task-Specific Patterns

Prompting for writing is different from prompting for analysis, which is different from prompting for code. Here are the most common task types and what makes them work.

Writing and Editing

What helps: A specific audience, tone, length, and purpose. An example of comparable work you admire. A clear statement of what the writing needs to accomplish.

What often goes wrong: Not specifying audience leads to generic writing. Not specifying tone leads to blandness. Not specifying length leads to over-generation.

"I'm writing [type] for [audience]. The goal is to [outcome].
Tone should be [description]. Here's what I have so far:
[draft]. Improve it, focusing especially on [specific aspect]."

Analysis and Reasoning

What helps: A clear question to answer. All the relevant data or text. Explicit instructions about what kind of analysis you want — descriptive, evaluative, comparative, causal.

What often goes wrong: Asking a vague question ("What do you think about this?") produces a vague analysis. The model doesn't know what dimension you want analyzed.

"Analyze X. First, identify the key factors at play.
Then evaluate each. Then give your overall assessment."

Code Generation

What helps: Specifying the language, the function or module's purpose, any relevant constraints (performance, dependencies, style guidelines), and what the inputs and outputs should be.

What often goes wrong: Code that works for the happy path but doesn't handle errors. Code that's technically correct but doesn't match your conventions.

"Write a function in [language] that [does X].
Inputs: [describe]. Outputs: [describe].
Edge cases to handle: [list].
Follow [project] conventions: [describe].
Include comments explaining non-obvious logic."

Summarization

What helps: Saying what you want from the summary — key decisions, action items, main arguments, specific topics — rather than asking for "a summary." Also specifying length and audience.

"Summarize this document. Focus on: [what matters].
Audience: [who will read this]. Length: [target].
Format: [prose / bullet list / structured sections]."

Brainstorming and Ideation

What helps: Constraints, actually. "Give me 20 ideas" produces worse results than "Give me 5 ideas that are genuinely novel and avoid the obvious answers." Constraints force the model to search beyond the first layer of common completions.

Giving Good Feedback

Iteration is a conversation. The quality of your follow-up feedback determines whether round two is better or whether you're thrashing.

Be Specific About What's Wrong

"That's not quite right" is unhelpful. "The opening paragraph is too formal for the audience — we need something that feels like a peer talking to a peer, not an executive briefing" is useful.

Separate What's Right from What's Wrong

"This is good but the conclusion is weak" is more useful than "rewrite this." It tells the model what to keep and what to fix.

"Keep everything through the third section. The conclusion
needs to be stronger — right now it just restates what came
before. Write a new conclusion that synthesizes the main
thread and gives the reader something to do with this."

Use Examples When Description Fails

If you can't articulate what's wrong or what you want instead, show the model. Find an example from elsewhere. "Make it sound more like [X]" often works better than a detailed description when you're trying to match a voice or style.

Ask the Model What It Needs

If you've iterated a few times without improvement, try asking directly: "What information would help you do this better? What are you uncertain about?" This often surfaces the gap in context that's causing the problem.

Prompting for AI Workflows

So far, we've mostly talked about single prompts for single tasks. But increasingly, AI is being used in multi-step workflows — chains of tasks where one AI output feeds the next.

Break Tasks into Stages

Complex tasks produce better results when broken into stages: research, then outline, then draft, then edit — rather than "write me a 2,000-word article about X."

This gives you checkpoints. You can review and adjust the outline before writing begins, rather than discovering structural problems after 2,000 words exist.

Be Explicit About What Stage You're In

"We've just finished the outline. Now we're drafting the body
based on that outline. Do not deviate from the structure we
agreed on."

This re-anchors the model and prevents drift.

Design Handoffs Carefully

When one AI output feeds another prompt (in automated pipelines), the output format matters. Structured, predictable outputs (JSON, specific delimited formats) are more reliable than prose when another prompt needs to consume them. Design the output of step N with the input needs of step N+1 in mind.

Keep the End Outcome in View

In multi-step workflows, it's easy to get absorbed in executing each step and lose sight of what the whole chain is supposed to produce. Periodically re-anchor on the final outcome.

"Remember, the end goal of all this is [X]. Does what we
have so far serve that goal?"

Knowing the Limits

Being a good prompter also means knowing when better prompting won't help. There are genuine limits.

Factual Reliability

Models will produce incorrect facts confidently. They're not looking things up — they're completing a pattern. For any specific fact that matters, verify from a primary source. This is non-negotiable.

Especially true for:

• Recent events (training data has a cutoff)
• Specific numbers and statistics
• Legal and medical information
• Anything where the cost of being wrong is high

Counting and Arithmetic

Language models are remarkably bad at tasks that seem trivially easy: counting words, adding numbers, verifying that something appears exactly N times. They're statistical pattern completers, not calculators. For anything that requires precise counting or arithmetic, check the output or use a tool instead.

Consistency at Scale

In a long document or complex output, models sometimes contradict themselves, change the format partway through, or forget a constraint from earlier. The fix is usually to break the task into smaller, checkable pieces.

The Confidently Wrong Failure Mode

This is the most dangerous failure mode. Because models are trained to be helpful and to produce fluent, confident-sounding text, they don't hedge the way a knowledgeable human would. A human expert says "I'm not sure, but..." A model says the same thing in the same voice regardless of how certain it should be.

Prompting for Coding Tools

Coding tools like Claude Code, Cursor, and GitHub Copilot operate in a context that's different from chat — they have access to your codebase, they can write files, and they often take multi-step actions. The prompting principles are similar, but the stakes are higher.

Provide Context About the System

// Worse
"Fix this function"

// Better
"Fix this function. It's part of our payment processing
pipeline. It receives user input from a web form, validates
it, and calls the Stripe API. The error we're seeing is
[error]."

Coding tools improve dramatically when they understand the broader system the code lives in. Use CLAUDE.md files (or equivalent) to capture persistent context about your project, conventions, and architecture.

Decompose Before You Generate

For significant features, describe the approach before writing code. "Before writing any code, tell me how you'd structure this feature and what files you'd create or modify." Review and adjust the plan before generation starts.

Small, Verifiable Steps

AI coding tools work best in small, reviewable increments. "Write the entire authentication system" is worse than "Write the user login endpoint, including input validation and error handling." You can verify the small step, provide feedback, and proceed with confidence.

Review What You Didn't Write

You're responsible for all code in your codebase, regardless of who or what wrote it. AI-generated code needs to be read, understood, and verified with the same care as any other code — arguably more care, because it can look correct while being subtly wrong.

Commit Before Handing Over

Before starting a significant AI-assisted coding session, commit what you have. This gives you a clean rollback point if the AI makes changes that are worse than what you started with. For branching strategies, rollback workflows, and other safety nets, see the Git field guide.

Common Work Scenarios

A few specific patterns worth having ready for common professional contexts.

Getting Useful Feedback

// Generic
"What do you think about this?"

// Better
"You are a [relevant role] reviewing this [document/proposal].
What are the three most significant weaknesses? What would
you want to see addressed before approving this? Be direct —
I need honest feedback, not encouragement."

Drafting Communication

"Write an email from me to [recipient] about [topic].
Goal: [what you want to happen].
Context: [relevant background].
Tone: [direct/warm/formal].
Length: [approx].
Key points to hit: [list].
Things to avoid: [list]."

Analyzing a Document

"I'm [your role] reviewing this [document type].
What I need to understand: [specific questions].
What decisions this informs: [context].
Analyze from that perspective and give me
[key risks / main arguments / action items / etc.]."

Preparing for a Meeting

"I have a meeting in an hour with [person/group] about [topic].
The outcome I want: [goal].
What are the most important questions I should ask?
What objections should I be prepared for?
What would make this meeting a success versus a failure?"

Learning Something New

"I'm trying to understand [topic].
My background: [what you already know].
Level of detail I need: [practical overview vs. deep dive].
My main question is: [specific question].
Start with the conceptual overview before getting into specifics."

How to Get Better

Prompting is a skill developed through practice, not a set of rules to memorize. Here's how to accelerate the learning curve.

Read the Output Diagnostically

When you get a bad output, don't just iterate randomly. Ask: "What did this model think I wanted? What would a reasonable person infer from my prompt?" Usually you can reverse-engineer the model's interpretation from the output. That tells you what to correct.

Keep a Personal Library

When a prompt works really well, save it. Not the whole conversation — just the key parts of the prompt that made it work. Over time you'll build a personal library of framings, formats, and approaches that you can reach for and adapt.

Test in Both Directions

When a change in prompting makes a meaningful difference, try the inverse: what happens if you remove that element? This builds intuition for which components are load-bearing and which are decoration.

Pay Attention to Failures

It's tempting to move on when a prompt doesn't work. Spend a minute asking why it didn't work. The failure modes are more instructive than the successes.

Teach Someone Else

The best way to solidify prompting skill is to explain your reasoning to someone else. Why did you frame the prompt this way? What alternatives did you consider? The act of explaining forces precision.

AI and Prompting — The Bigger Picture

Prompting is a skill worth developing, but it's worth keeping in perspective.

It's Not Magic

Better prompting improves outputs. It doesn't transform a model into something it isn't. If a task is genuinely beyond what the model can do well, better framing won't fix it. Knowing the limits is as important as knowing the techniques.

It Changes Fast

Model capabilities improve quickly. Techniques that were essential a year ago (specific token tricks, elaborate jailbreaks, verbose instructions for basic tasks) are often unnecessary now. Current models understand intent well and follow instructions precisely. You don't need baroque prompts to get good behavior — clear, direct instructions work.

The Fundamental Skill Doesn't Change

What remains constant: the ability to think clearly about what you want, articulate it precisely, give appropriate context, and iterate with diagnostic feedback. These are fundamentally good communication skills, applied to a new kind of audience.

AI Is a Collaborator, Not an Oracle

The most productive framing is a skilled collaborator who needs good direction, not an oracle to query or a search engine to extract answers from. It will match your energy and specificity. It needs context you take for granted. It can catch things you've missed and push back usefully. It also makes mistakes, confabulates, and needs to be verified.

Work with it like you'd work with a smart, capable person who's new to your specific situation. Brief it well, give useful feedback, and verify the work before you ship it.

Prompting Cheat Sheet

Elements of a Good Prompt

When Your First Output Isn't Right

1. Add specificity — where did the model have to guess?
2. Show an example — when description fails, examples work
3. Ask it to reflect — have the model identify what's weak before rewriting

Red Flags in Outputs

• Confident claims you can't verify → check them
• Generic advice that doesn't account for your situation → add more context
• Exactly the length you'd expect without constraints → you needed format instructions
• Clichés and filler phrases → ask for more direct prose

Things AI Is Bad At

The Outcome Context Technique

// Instead of "do X," try:
"I'm trying to achieve [outcome]. Here's what I have so far.
Does this approach serve that goal, and if not, what would
you change?"

Prompting for Code

What You Can Do Now

The best way to improve is to notice when AI outputs aren't quite right and ask one question: "What was missing from my prompt that would have made this better?"

Start with whatever task you use AI for most. The next time it produces something mediocre, don't just accept it or retry randomly. Diagnose. Add the missing context. Specify the format. Give an example. See what changes.

After a few weeks of deliberate iteration, prompting will stop feeling like guesswork. You'll have internalized the patterns — not because you memorized them, but because you built them from experience.

That's the goal: not knowing the rules, but having the instincts.