30 Best Llama Prompts

<context> Language / framework: [e.g. Python 3.12 / FastAPI] What the code should do: [EXPECTED BEHAVIOR] What it actually does: [ACTUAL BEHAVIOR / ERROR] Code: [PASTE CODE] </context> <task> Debug this step by step: 1. Restate what the code is trying to do in one sentence. 2. Trace the execution and identify the root cause of the bug. 3. Show the corrected code with the changed lines clearly marked. 4. Explain why the original failed and how the fix resolves it. 5. Suggest one test case that would have caught this. </task>

<context> Language: [LANGUAGE] Function purpose: [WHAT IT DOES] Inputs: [PARAMS AND TYPES] Output: [RETURN TYPE / SHAPE] Edge cases to handle: [LIST] </context> <task> Write the function: 1. Implement it cleanly with type hints and a docstring. 2. Handle every edge case I listed explicitly. 3. Add inline comments only where the logic is non-obvious. 4. Below the code, list any assumptions you made. Return only the function plus the assumptions list — no surrounding prose. </task>

<context> Language / framework: [LANGUAGE] What this file does: [PURPOSE] Code: [PASTE FILE] </context> <task> Review it like a senior engineer: 1. List issues grouped as Bugs, Security, Performance, Readability. 2. For each issue give the line area, the problem, and a concrete fix. 3. Rank the issues by severity (critical / major / minor). 4. Note one thing the code does well. Do not rewrite the whole file — point to specific changes. </task>

<context> Language: [LANGUAGE] My level with this language: [LEVEL] Code to explain: [PASTE CODE] </context> <task> Walk me through this code: 1. Give a one-line summary of what it accomplishes overall. 2. Break it into logical sections and explain each in plain language. 3. Call out any clever, risky, or non-idiomatic patterns. 4. Rewrite the single most confusing part with clearer naming as an example. </task>

<context> Language: [LANGUAGE] Goal of the refactor: [e.g. reduce nesting, extract functions, improve naming] Constraints: [e.g. keep public API unchanged, no new dependencies] Code: [PASTE CODE] </context> <task> Refactor this code: 1. Apply the refactor goal without changing observable behavior. 2. Show the before/after for each meaningful change, with a one-line reason. 3. Respect every constraint I listed. 4. End with a short note on what is now easier to maintain. </task>

<context> What I'm writing: [TYPE — email, post, article section] Goal: [WHAT IT SHOULD ACHIEVE] Audience: [WHO] My voice sample: [PASTE 2-3 SENTENCES I WROTE] Key points to hit: [LIST] </context> <task> Write the draft: 1. Match the tone, rhythm, and vocabulary of my voice sample. 2. Cover every key point I listed, in a logical order. 3. Keep it concise — cut any sentence that doesn't earn its place. 4. End with a clear next step or call to action for the reader. </task>

<context> Content it's for: [TOPIC / SUMMARY] Platform: [WHERE IT WILL LIVE] Audience: [WHO] Desired feeling: [e.g. curiosity, urgency, trust] </context> <task> Generate options: 1. Write 10 headline variations spanning different angles (curiosity, benefit, contrarian, specific-number, how-to). 2. For my top 3 favorites, write a matching one-line opening hook. 3. Label each headline with its angle. 4. Avoid clickbait that the content can't deliver on. </task>

<context> Draft to edit: [PASTE DRAFT] Goal: [e.g. cut 30%, more punchy, more formal] Keep intact: [ANY LINES OR IDEAS THAT MUST STAY] </context> <task> Edit the draft: 1. Tighten toward the goal while preserving meaning and the lines I marked. 2. Cut redundancy, weak qualifiers, and filler phrases. 3. Return the edited version, then a short bullet list of what you changed and why. 4. Flag any sentence where you were unsure about my intent. </task>

<context> Source content: [PASTE OR SUMMARIZE] Repurpose into: [TARGET FORMATS — e.g. tweet thread, LinkedIn post, newsletter blurb] Audience and tone per format: [NOTES] </context> <task> Repurpose the content: 1. For each target format, produce a version sized and styled for that platform. 2. Lead each with the single most compelling idea from the source. 3. Keep the core message consistent across all formats. 4. Label each output with its format. </task>

<context> Working title: [TITLE] Thesis / main argument: [ONE SENTENCE] Audience: [WHO] Target length: [WORD COUNT] </context> <task> Build a detailed outline: 1. Propose a structure of sections with a one-line purpose for each. 2. Under each section, list 2-3 bullet points of what to cover. 3. Suggest where to place examples, data, or stories. 4. Note the strongest possible opening and closing line. </task>

<context> Problem to solve: [STATE THE PROBLEM] Known facts / constraints: [LIST] What a good answer looks like: [SUCCESS CRITERIA] </context> <task> Reason it through carefully: 1. Restate the problem and what's being asked. 2. Think step by step, showing each inference and the fact it rests on. 3. State the answer clearly. 4. Double-check the answer against the constraints and note your confidence level. If the problem is underspecified, say what's missing instead of guessing. </task>

<context> Things to compare: [ITEM A] vs [ITEM B] (vs [ITEM C]) Dimensions I care about: [LIST] My use case: [HOW I'LL USE THE CONCLUSION] </context> <task> Compare them rigorously: 1. Build a table scoring each item across my dimensions. 2. Below the table, explain the most important difference in depth. 3. Recommend which fits my specific use case and why. 4. Note any scenario where the recommendation would flip. </task>

<context> Problem / symptom: [WHAT WENT WRONG] Context: [SYSTEM / SITUATION] What I've already ruled out: [LIST] </context> <task> Find the root cause: 1. Run a Five Whys analysis, asking 'why' until you reach a root cause, not a symptom. 2. At each level, note what evidence would confirm or refute it. 3. Distinguish the root cause from contributing factors. 4. Propose one fix that addresses the root cause, not just the symptom. </task>

<context> Plan, argument, or forecast: [STATE IT] Domain: [CONTEXT] Stakes: [WHAT'S RIDING ON IT] </context> <task> Audit the hidden assumptions: 1. List every assumption this depends on, including the implicit ones. 2. Rate each assumption: how confident are we, and how damaging if wrong? 3. Highlight the one or two load-bearing assumptions that deserve real scrutiny. 4. Suggest a cheap way to test each load-bearing assumption. </task>

<context> Quantity to estimate: [WHAT] What I roughly know: [ANY ANCHORS OR DATA] Why I need it: [PURPOSE] </context> <task> Produce a Fermi estimate: 1. Break the quantity into estimable sub-factors. 2. State a reasonable value and source of reasoning for each factor. 3. Multiply through to a final estimate, showing the arithmetic. 4. Give a low/expected/high range and name the biggest source of uncertainty. </task>

<context> Assistant's job: [WHAT THE ASSISTANT SHOULD DO] Target Llama model: [e.g. Llama 3.1 8B via Ollama] Audience / users: [WHO TALKS TO IT] Hard rules and boundaries: [WHAT IT MUST AND MUST NOT DO] </context> <task> Write a production-ready system prompt: 1. Open with a clear role and primary objective. 2. Specify tone, output format, and length expectations. 3. Encode the hard rules as explicit do/don't instructions. 4. Add fallback behavior for when the user asks something out of scope. 5. Return only the finished system prompt, ready to paste. </task>

<context> Task the model performs: [TASK] Exact output format required: [e.g. JSON schema, fixed sections, table] What must never appear: [e.g. no preamble, no apologies, no markdown] </context> <task> Write an instruction block that locks the output format: 1. Describe the required structure precisely, with a filled-in example. 2. State explicitly what the model must omit (preamble, explanations, etc.). 3. Add a rule for how to handle missing data within the format. 4. Keep it directive and unambiguous — no soft language. </task>

<context> Task: [WHAT THE MODEL SHOULD LEARN TO DO] Good output looks like: [DESCRIBE OR PASTE ONE EXAMPLE] Common mistakes to avoid: [LIST] </context> <task> Build a few-shot prompt: 1. Write 3 diverse input -> output example pairs that demonstrate the task. 2. Make the examples cover edge cases and the mistakes I listed. 3. Keep the format of every example identical so the pattern is obvious. 4. End with the template for the real input the model should complete. </task>

<context> Desired persona: [e.g. blunt mentor, friendly tutor, terse senior engineer] Use case: [WHERE IT'S USED] Things the persona should never do: [LIST] </context> <task> Write persona instructions: 1. Describe the voice with concrete traits (word choice, sentence length, attitude). 2. Give two short sample exchanges showing the persona in action. 3. Specify what the persona does when it doesn't know something. 4. List the forbidden behaviors as explicit rules. </task>

<context> My legitimate task: [TASK] Why the model keeps over-refusing or over-hedging: [WHAT IT SAYS] Context that makes this clearly appropriate: [DETAILS] </context> <task> Rewrite my prompt to get a direct, useful answer: 1. Add the context that establishes the request is legitimate and appropriate. 2. State the role and expertise frame that fits the task. 3. Ask explicitly for a direct answer without disclaimers or hedging. 4. Return the improved prompt, then explain in one line why it works better. </task>

<context> Document(s) to query: [PASTE TEXT OR DESCRIBE FILE] My question: [WHAT I WANT TO KNOW] Running on: [e.g. Ollama, local, no internet] </context> <task> Answer strictly from the provided text: 1. Answer my question using only what's in the document. 2. Quote the exact passage that supports each claim. 3. If the document doesn't contain the answer, say so plainly — do not use outside knowledge. 4. Note any part of my question the document only partially addresses. </task>

<context> Text that may contain sensitive info: [PASTE TEXT] What counts as sensitive here: [e.g. names, emails, IDs, financials] Running locally so nothing leaves my machine: yes </context> <task> Redact and report: 1. Return the text with every sensitive item replaced by a typed placeholder like [NAME_1], [EMAIL_1]. 2. List each redaction with its placeholder and category. 3. Flag anything borderline that I should review manually. 4. Do not alter any non-sensitive content. </task>

<context> Project: [WHAT YOU'RE BUILDING] Stack: [LANGUAGES / FRAMEWORKS] Model: [e.g. Code Llama / Llama 3.1 via Ollama] My skill level: [LEVEL] </context> <task> Act as my local pair programmer for this session: 1. Confirm the stack and ask only the essential clarifying questions. 2. When I share code, default to: explain, spot issues, then suggest the smallest good change. 3. Keep responses short and code-forward — I'm iterating fast. 4. At any time if I type 'recap', summarize what we've built and what's next. </task>

<context> Goal: run a Llama model locally on my hardware. My hardware: [GPU/CPU, VRAM, RAM] Use case: [e.g. chat, coding, summarization] Quality vs speed priority: [WHICH MATTERS MORE] </context> <task> Recommend a local setup: 1. Suggest which Llama model size fits my hardware and use case. 2. Recommend a quantization level (e.g. Q4, Q5, Q8) and explain the tradeoff. 3. Estimate whether it will run comfortably given my VRAM/RAM. 4. Note one setting to adjust if it's too slow and one if quality is too low. </task>

<context> Topic or problem: [WHAT YOU'RE THINKING ABOUT] Why it's private: [e.g. unannounced idea, personal matter] Where I am in my thinking: [EARLY / STUCK / DECIDING] </context> <task> Brainstorm with me, no judgment: 1. Ask one sharp question to understand where I'm actually stuck. 2. Offer 5-7 distinct angles or ideas, including at least one unconventional one. 3. For each, note the upside and the catch in a few words. 4. End by suggesting which idea is worth exploring next and why. </task>