Learn AI Prompting,
Simply.

A single sentence assigning a role changes the vocabulary, depth, and tone of every response. "You are a nutritionist" gets you different output than "you are a personal trainer" — even if you ask the exact same question.

Start with exactly what you want done. Write, Explain, Summarize, Compare, Rewrite, Create, List, Translate, Simplify, Critique — the verb does a lot of work. Vague nouns ("something about X") leave AI guessing.

AI doesn't know who you are, what you already know, why you're asking, or what you're going to do with the answer. Any of those details you share will improve the response. You don't need all of them — just the ones that matter for your specific request.

If you want bullet points, say so. If you want a table, say so. If you want it under 100 words, say so. AI will match whatever structure you request — but if you don't ask, it will guess, and it might guess wrong.

Words like "good," "simple," "short," and "professional" mean different things to different people — and different things to AI. If you say "write a short bio," AI doesn't know if you want two sentences or two paragraphs.

Sometimes the gap is between what you literally asked for and what you actually needed. AI answers what you wrote — not what you meant. Think about what you'll do with the output before you write the prompt.

AI starts every conversation knowing nothing about you. If it's giving generic answers, you haven't given it your situation yet. The fix is usually one or two sentences about who you are, why you're asking, and what you already know.

AI has a training cutoff — it may not know about recent events, your proprietary data, or niche information in specialized fields. If accuracy matters and the topic is current, specific, or highly technical, always verify the response with real sources.

Complex multi-part requests produce long, scattered, mediocre answers. AI tries to satisfy everything and ends up fully satisfying nothing. The fix is to split the request into steps — do one thing well, then the next.

AI's first response is a starting point, not a final draft. The real power is in the follow-up. If something's off, say exactly what you'd like changed — don't start over from scratch. The conversation context stays with you.

This is the most reliable method. AI takes word limits seriously when they're explicit.

Specifying a tight format implicitly enforces brevity — bullet points, a numbered list with one sentence per item, or a table force the AI to be concise by structure.

AI often starts with a sentence or two explaining what it's about to do. You can eliminate this entirely. This alone cuts a typical response by 20–30%.

Saying "write more" often just produces padding. Asking for specific types of depth — examples, reasoning, edge cases — gets you longer and actually better content.

Explicit signals for depth work. Phrases like "at least 400 words," "a comprehensive guide," or "cover all the nuances" signal that you want more, not less.

When you want more detail on a specific part of the answer without asking for the whole thing to be redone.

When the response was mostly right but one thing needs to change. Don't rewrite from scratch — just name what to change.

When AI gave you a general answer but you need it tailored to your specific context. Add your details and ask it to redo it.

When you want to see a different approach without losing the first one. Useful for creative work, emails, arguments.

A good way to stress-test any plan or argument. Ask AI to push back on what it just told you.

Generic tone words ("professional," "friendly") are better than nothing, but they leave a lot of room for interpretation. The more specific your descriptor, the closer the output gets on the first try.

Useful tone descriptors to try:

The fastest way to get a specific style is to show it — paste in a sample of writing you like and ask AI to match it. This is called few-shot prompting, and it's more reliable than trying to describe a style in words.

Negative instructions ("don't sound like a corporate press release") are often more precise than positive ones. Name what you're trying to avoid and AI will steer away from it.

Referencing a well-known style — a publication, author, or type of writing — gives AI a rich set of conventions to draw from instantly.

Tell AI what the audience already knows, not just who they are. "Experts" is vague. "Mechanical engineers who understand fluid dynamics but not software architecture" is specific.

Vocabulary is one of the clearest signals of audience calibration. Being explicit about jargon prevents the AI from either talking over someone's head or talking down to them.

The same topic matters for different reasons to different people. A CEO cares about ROI. An engineer cares about implementation. A first-time buyer cares about risk. Telling AI what your audience cares about changes what it emphasizes.

If you write for multiple audiences regularly — teachers writing for students and parents, developers writing for technical and non-technical stakeholders — ask for both versions in a single prompt.

"Explain like I'm 10" is more than a meme — it's a remarkably effective prompt technique. Grade levels and ages give AI a clear calibration target for vocabulary and concept depth.

Analogies are the fastest path to real understanding. You can request one directly — and the more you customize the analogy domain to something the reader knows, the better it lands.

The most effective way to force simplicity is to explicitly forbid the technical terms that let AI hide behind complexity. If it can't use jargon, it has to actually explain the concept.

One of the most useful — and underused — patterns: after the explanation, ask AI to quiz you or ask you to explain it back. If you can't explain it in your own words, you don't actually understand it.

AI generates text by predicting what words are most likely to come next, based on patterns from its training data. It's extremely good at this — which means it can produce convincing-sounding text even when no correct answer exists in its training. It doesn't "look things up." It completes patterns.

Think of it like autocomplete that's read millions of books. When asked a question, it produces the most statistically plausible-looking answer — whether or not that answer is true.

Humans who don't know something can say "I'm not sure." AI models — unless specifically designed to — don't naturally stop and admit uncertainty. They continue generating fluent, confident-sounding text even when they have no reliable basis for it.

This is especially dangerous for niche topics, recent events, and specific data points where the training data was thin or absent.

Hallucination risk isn't uniform. Broad conceptual explanations (how photosynthesis works) are far more reliable than specific claims (a 2019 study found that 73% of...). Here's how to think about risk by content type:

You can instruct the AI to tell you when it's unsure rather than guessing. This doesn't eliminate hallucination, but it makes uncertainty visible.

When AI has to show its work, it's harder to invent things convincingly. Asking "how do you know this?" or "what's the basis for that?" forces it to reveal when its foundation is thin.

This is the single most dangerous common habit. AI-generated citations look completely real — correct journal name format, plausible author names, realistic publication years — and they often don't exist. Always find sources yourself using Google Scholar, PubMed, or the primary publication.

Every AI system has a setting called "temperature" that controls how random its responses are. High temperature = more creative and varied. Low temperature = more predictable and consistent. Most consumer AI tools run at a medium temperature by default — creative enough to be interesting, predictable enough for factual tasks.

Developer note: if you're using the API, you can set temperature directly. In consumer products, it's usually fixed — but you can influence effective temperature through your prompt.

Identical meaning, different words → different outputs. AI is extremely sensitive to how a question is framed. Small changes in phrasing can shift which parts of its training it draws from, changing the emphasis, structure, and content of the answer.

Both are about remote work. But Phrasing B will produce very different content — more emotional, more specific, more focused on loss — because the framing steers the model's attention differently.

For open-ended tasks — name suggestions, creative writing, strategic advice, opinion-based questions — there is no single correct answer. Variation is expected and appropriate. The AI isn't getting it "wrong"; it's exploring a space that has many valid outputs.

AI-generated citations are the highest-risk output on this entire site. They look exactly right: correct journal name format, plausible author surnames, realistic publication years, proper DOI structure. And they frequently do not exist.

Without an audience, AI picks the most average possible reader — usually someone with moderate knowledge and no strong preferences. That means the output is rarely optimized for your actual situation.

What changes: The specific audience (CFO, non-technical, budget context) shifts the vocabulary, the examples, the depth, and even what aspects of machine learning get emphasized.

The purpose of the output changes what good output looks like. An email to a boss needs a different structure than the same information in a slide deck or a text message.

Subjective quality words — "good," "professional," "engaging," "better" — give AI nothing to work with. Define what those words mean in your context.

Without constraints, AI fills all available space. It will write 500 words when you needed 50, include five sections when you needed one, and go broad when you needed narrow.

Sometimes the prompt describes a situation but doesn't say what to do with it. AI has to guess — and it often guesses wrong.

Summarizing, translating, explaining, classifying, editing — tasks that are common and clearly described in language. AI has seen millions of examples of these during training, so your request maps cleanly onto what it already knows how to do.

Describing a writing style in words is hard. Showing it is easy. Paste 2–3 samples from a newsletter, blog, or internal document and ask AI to match the style for new content.

AI doesn't know your internal taxonomy. If you're sorting tickets, tagging content, or labeling data using your own system, show it a few labeled examples and it'll apply your logic to new inputs.

When you need AI to produce output in an exact, repeated structure — especially for structured data or templates — showing the format once is more reliable than describing it.

Any time a problem has multiple steps that build on each other, chain-of-thought helps. This includes arithmetic, algebra, probability, scheduling, and logic puzzles.

When you're weighing options with trade-offs, asking AI to reason through each factor before concluding produces more nuanced and trustworthy recommendations than just asking "which should I choose?"

For code bugs, logical errors, or anything where you need to understand the reasoning — not just the fix — chain-of-thought makes the AI's diagnostic process visible and checkable.

You can define the exact template — AI will fill it in. This is especially useful for recurring outputs you need to look the same every time.

Don't just say "you are a doctor." Specify the specialty, experience level, and context. The more specific the role, the more the output draws on that domain's vocabulary, conventions, and concerns.

Tell AI whether to use technical jargon or avoid it. "Write for a peer" signals use field-standard terminology. "Write for a layperson" signals plain language. Without guidance, AI picks an awkward middle.

Experts don't just state facts — they interpret them, identify what matters, and tell you what they'd actually do. Prompting for opinions and recommendations unlocks a different kind of output than asking for summaries.

Assigning a persona sets the expertise level, vocabulary, perspective, and voice of everything that follows. It's the fastest way to shift the register of AI output — from generic to domain-specific, from formal to casual, from comprehensive to opinionated.

The task is the core instruction — and it should always start with an action verb. Vague tasks produce vague outputs; precise tasks produce precise outputs. The task answers: what exactly should AI produce?

Context is the background information that makes the output specific to your situation rather than generic. This is the ingredient most people forget — and the one that produces the biggest quality jump when added.

Useful context includes: who the audience is, what they already know, what you're trying to achieve, what constraints exist, what's been tried before, what the output will be used for.

Format controls the shape, length, and structure of the output. Without it, AI will choose the most common format for that type of request — which may not be what you need.

AI often opens with a sentence about what it's about to do. Add "no preamble" or "skip the intro" to eliminate this — it typically cuts 15–25% of unnecessary length immediately.

"Give me more" or "make it longer" produces padding, not depth. Ask for the specific depth you need — examples, reasoning, edge cases, sub-points — and the length follows naturally.

Broad questions produce comprehensive answers. When you only need one part, either narrow the question or explicitly constrain the scope.

The phrase "step by step" is a reliable trigger for numbered, sequential output. It also activates chain-of-thought reasoning — AI thinks through the sequence rather than just listing things.

Generic steps ("Step 1: Research") are not useful. Specify what you want inside each step — the action, the why, an example, a warning — and AI will include it consistently across all steps.

Steps are most useful when AI knows exactly where you're starting and what "done" looks like. Without this, it may assume the wrong starting conditions or stop too early.

Good procedural guides include what to watch for, not just what to do. Asking AI to include warnings, common mistakes, or "check that this worked" verification steps makes instructions genuinely usable.

"5th grade math" covers an enormous range. "5th grade math — introducing fractions as equal parts of a whole (first lesson on fractions, students understand division)" is a planning brief.

Time changes everything. A 45-minute block needs a completely different structure than a 90-minute block. And naming your preferred format explicitly (warm-up / instruction / activity / exit) prevents AI from inventing one you'd never use.

This is the ingredient most teachers forget — and the one that most prevents generic output. Tell AI what prior knowledge to build on and what gaps to address, and the plan will match your actual students, not a hypothetical class.

Class size, ELL students, IEP accommodations, mixed ability levels — any of these you include will make the plan more realistic. You don't have to share details that feel too specific; even "mixed ability levels" or "several ELL students at intermediate level" is enough to shift the output meaningfully.

If you include the objective, AI builds the lesson toward it. If you don't, AI writes a generic objective — which may or may not match your unit goals or standards. Including a verb from Bloom's Taxonomy (identify, analyze, compare, construct) makes the objective even sharper.

Grade level and reading level are not the same thing. A 5th grade student might read at a 3rd grade level. Specifying both gives AI much better calibration than grade alone.

For below-level explanations: explicitly ban or define technical terms. For on-level: say which vocabulary words to introduce and define. For above-level: name the technical terms students should encounter. This is more reliable than trusting AI to infer vocabulary level from a grade alone.

This is the real time-saver. One prompt, three usable versions. Label them explicitly and you can paste them directly into differentiated reading packets or small-group materials.

Generic analogies ("it's like a highway") don't stick. When you know what your students love — sports, gaming, cooking, YouTube, a specific TV show — asking AI to use that domain produces explanations that actually land.

Without a specific breakdown, AI defaults to the most common format (usually multiple choice) and the most comfortable difficulty (usually recall). Name the distribution you want explicitly.

AI writes questions for the topic as it understands it — not for what you actually taught. If your unit had specific emphases, readings, or vocabulary, name them. AI will write questions that test your content, not a generic treatment of the subject.

Naming Bloom's levels is the most reliable way to control the cognitive demand of quiz questions. AI knows exactly what these levels require and will calibrate accordingly.

Bad AI-generated multiple choice often has three obviously wrong answers and one obviously correct one — which makes the question useless for assessment. Ask explicitly for plausible distractors that represent common misconceptions.

Without criteria, AI gives generic writing feedback. With your rubric, it evaluates the specific things you're actually assessing. This is the difference between feedback a student can act on and generic praise.

Feedback for a 3rd grader should sound nothing like feedback for an 11th grader. And the emotional register matters — feedback that discourages a struggling student or undersells a strong one does more harm than good. Set both explicitly.

Instead of pasting 30 student paragraphs into AI, use AI to generate a bank of comment templates for common patterns — then apply them yourself with small personalizations. This is faster, safer for student privacy, and keeps your voice in the feedback.

If you want to understand what your whole class is struggling with — not individual feedback — paste 3–5 anonymized samples and ask AI to identify common patterns. This is more useful than grading each one separately and is especially valuable for planning your next lesson.

Start with any text — an article, a chapter summary, a primary source — and ask AI to produce multiple versions at different Lexile or grade-equivalent reading levels. The content stays consistent; the vocabulary and sentence complexity changes.

The same activity can be scaffolded differently without changing the core task. Ask AI to rewrite your instructions with more or less support — sentence starters, word banks, partially completed examples — for students who need it.

Discussion questions, exit tickets, and check-for-understanding questions can all be tiered by cognitive demand. Use Bloom's Taxonomy levels explicitly to get questions that genuinely stretch different learners.

Once you understand how to tier individual elements, you can ask AI to produce a full differentiated learning packet in a single extended prompt — reading passage, activity, and exit ticket all in three versions. This is the real time-saving payoff.

Name, role, and persona. Sets the voice and the frame for everything else. Be specific about expertise level and tone — vague identity produces vague output.

Explicit scope guards are the most important part of a production system prompt. Without them, users can steer the AI off-topic and onto territory you haven't designed for. State both what it should do and what it should refuse — with a graceful redirect for the refusals.

How it handles uncertainty, whether it asks clarifying questions, how it manages sensitive situations. These rules prevent the AI from improvising in ways that create support headaches.

Length constraints, structure, language matching. Without format instructions, output length and structure varies unpredictably — which breaks UI layouts and creates inconsistent user experiences.

The most reliable focus technique is explicit scope definition in the system prompt. State in-scope topics positively, then state out-of-scope topics explicitly — and specify exactly what to do when something falls outside scope. "Gracefully redirect" is not enough — write the redirect script.

Generic scope guards get bypassed by creative framing. If your product has predictable off-topic patterns — users asking a coding assistant to write their essay, or asking a recipe bot for medical advice — name those specific cases and handle them explicitly.

For higher-stakes applications, add a classification step before the main response. A fast, cheap first call classifies the user's intent. Only on-topic intents get routed to the full response. Off-topic intents get a redirect without ever reaching your main prompt.

Every product AI needs adversarial testing before launch. Write a list of off-topic or boundary-pushing prompts and test them against your system prompt. If the AI complies with any of them, tighten the relevant scope rule.

Wrapping your document in XML-style tags makes it unambiguous where the reference material starts and ends — and tells the AI it's a source to consult, not instructions to follow. This reduces the chance it confuses document content with your prompt instructions.

Without explicit grounding, AI will blend your document with its training knowledge — and you can't tell which is which in the output. A grounding instruction forces it to stay within the document you provided. For compliance-sensitive or high-accuracy applications, this is non-negotiable.

Every AI model has a context window — a limit on how much text it can process at once. For long documents, you have two options: chunk (split into pieces and process sequentially) or retrieve (find the relevant section first, then pass only that to the model).

For auditable applications, ask AI to quote or reference the specific part of the document it's using. This makes hallucination visible — if it can't cite a source, it's improvising. It also makes debugging much faster when outputs are wrong.

Agents are not just chatbots with more features. They introduce fundamentally different failure modes that require deliberate design to manage.

The standard chain. Output of step N is input to step N+1. Use for ordered pipelines where each step builds on the last.

Multiple LLM calls run simultaneously on different aspects of the same input. A final synthesis call combines them. Faster than sequential for independent subtasks.

Call 1 generates output. Call 2 validates it against criteria. If it fails, retry call 1 with the failure reason as additional context. Essential for structured output and quality-gated pipelines.

A fast classifier call categorizes the input. The result routes to a specialized prompt optimized for that category. Each specialized prompt is better than a single general-purpose prompt trying to handle all cases.

Model-specific tricks — "Say 'DAN mode activated'" or "Use the following magic phrase" — are fragile and version-dependent. Portable prompts describe the desired behavior in plain, explicit terms. If you find yourself using a trick, replace it with a direct instruction.

Different models have different default output styles. Claude tends toward structured prose. GPT tends toward bullet points. Gemini often produces longer responses. A prompt that doesn't specify format will produce different output on each model. Lock the format explicitly so output is consistent regardless of which model is handling the request.

A prompt that gets 95% accuracy on GPT-4 may drop to 70% on a smaller open-source model. Don't assume portability — test it. Build a small eval set of representative inputs and expected outputs, run it across your target models, and document where each model diverges.

Style descriptions ("be concise and professional") are interpreted differently by different models. A few-shot example of the exact output you want is more portable — every model can pattern-match on a concrete example better than it can interpret a subjective description.

If you're running the same prompt across multiple models, keep the core prompt logic in a template with model-specific overrides for the parts that vary. This way, when you switch models, you only update the delta — not the whole prompt.

→ Supermaven. Built specifically for low-latency autocomplete using a custom architecture. Noticeably snappier than Copilot for single-line and function completions. Free tier is generous.

→ Cursor. The @codebase command indexes your entire project and lets you ask questions like "where is auth handled?" or "refactor this pattern across all files." The agent mode can plan and execute multi-file edits.

→ GitHub Copilot Enterprise. Native to the GitHub ecosystem, SOC 2 compliant, supports org-wide policy controls. If procurement and compliance matter more than raw capability, this is the path of least resistance.

→ Codeium (free tier). Strong privacy controls, free forever for individuals, broad editor support. Windsurf (by Codeium) adds an agentic layer similar to Cursor if you upgrade.

Paste the single relevant file or function directly into the chat. Keep it focused — more context isn't always better if it's the wrong context.

Use @file mentions in Cursor or paste a condensed version of each file with irrelevant functions replaced by comments like // ... 40 lines of unrelated utility functions omitted.

Use Cursor's @codebase indexing or Claude Code's project mode. Start with a planning conversation ("what files will we need to touch and why?") before writing any code. Break into sub-tasks and handle each in a focused session.

"Add a createdAt / updatedAt timestamp to every Prisma model that's missing one" — this is perfect for an agent. The task is unambiguous, the success criteria are clear, and the pattern repeats across files.

Renaming a function used in 40 files, migrating from one auth library to another, converting a JavaScript codebase to TypeScript. These tasks are tedious for humans and exactly the kind of systematic application-of-a-pattern that agents handle well.

Scaffolding a new CRUD resource — model, migration, API routes, service layer, basic tests. Agents can produce a working, consistent scaffold in a few minutes that would take an hour manually.

Client says: "We need the system to be fast and easy to use."

Prompt: "Translate the following vague requirement into 3–5 specific, measurable, testable requirements. Consider performance benchmarks, usability standards, and user acceptance criteria: '[vague requirement]'"

AI produces: Page load under 2s on 4G. Task completion rate ≥85% in usability testing. New users complete core workflow without assistance in under 5 minutes.