AI Content Hub

Tell the model what NOT to do in addition to what you want. For example, 'Explain quantum computing without using analogies or metaphors.' Negative constraints often produce more focused and accurate outputs than positive instructions alone.

When you need a specific output format, include a concrete example in your prompt rather than just describing it. Showing the model 'Output should look like: {name: string, score: number, summary: string}' with a filled example is far more effective than verbal descriptions alone.

Use specific, detailed prompts to get more accurate responses from LLMs and reduce token costs.

Keep your prompts concise but informative to maximize the value of each token.

Use model-specific prompting techniques: Claude likes XML, GPT likes markdown, Gemini handles multimodal well.

For complex tasks, don't try to write the perfect prompt in one go. Start with a simple instruction, see the result, and then iteratively add more constraints, context, and examples to refine the output until it meets your requirements. This is more effective than starting with an overly complex prompt.

To guide the model away from undesired outputs, tell it what *not* to do. For example, add constraints like 'Do not use technical jargon,' 'Avoid mentioning price,' or 'The response should not be longer than two paragraphs.'

To get structured data, explicitly ask the LLM to format its response as JSON, a markdown table, or a numbered list. For example: 'Compare the top 3 smartphones and provide the output in a markdown table with columns for Model, Price, and Key Feature.'

When asking an LLM to perform a task with a specific format, provide a few examples (2-3) in your prompt. This 'few-shot' approach helps the model understand the desired input-output pattern, leading to more consistent and accurate results.

Start your prompt by telling the model to act as an expert persona. For example, 'Act as a senior copywriter specializing in luxury brands.' This primes the model to adopt the desired tone, style, and domain knowledge, leading to higher-quality outputs.

Use delimiters like triple quotes (''' '''), triple backticks (``` ```), or XML tags (<example></example>) to clearly separate instructions from the content you want the model to process. This helps prevent the model from getting confused.

When prompting an LLM, be as clear and specific as possible. Define the desired format, length, tone, and role for the AI. For example, instead of 'Write about dogs,' try 'Write a 500-word blog post about the benefits of adopting a rescue dog, in a friendly and informative tone.'

When prompting an LLM, be as clear and specific as possible. Define the desired format, length, tone, and role for the AI. For example, instead of 'Write about dogs,' try 'Write a 500-word blog post about the benefits of adopting a rescue dog, in a friendly and informative tone.'

The 'temperature' parameter controls randomness. Lower values (e.g., 0.2) make output more deterministic and focused. Higher values (e.g., 0.8) increase creativity and diversity. Adjust it based on your task.

If an LLM struggles with a complex task, break it into smaller, simpler sub-tasks. Solve each part sequentially, and then combine the results. This is often more effective than one large prompt.

Instruct the LLM to adopt a specific persona or role (e.g., 'You are a helpful assistant specializing in physics.'). This can significantly shape the tone, style, and content of its responses.

Sometimes it's effective to tell the LLM what to avoid. For example, 'Write a product description. Do not use clichés or overly technical jargon.'

For complex reasoning, you can often trigger CoT by simply appending 'Let's think step by step.' to your prompt. The model will then show its reasoning process before the final answer.

Provide a few examples (input/output pairs) in your prompt to guide the LLM's response. This is called few-shot prompting and can significantly improve performance on specific tasks.

Use delimiters like triple backticks (```), XML tags (<tag></tag>), or quotes ("") to clearly separate different parts of your prompt, such as instructions, context, examples, and input data.

When generating content, tell the LLM who the target audience is (e.g., 'Explain this to a 5-year-old,' or 'Write this for an expert audience.'). This helps tailor the complexity and tone.

Start the desired output for the LLM. For instance, if you want a list, start your prompt with the beginning of the list: 'Here are the steps:
1.' This can guide the model effectively.

If accuracy on specific facts is crucial, provide those facts within the prompt. This helps to ground the LLM and reduce the chance of hallucinations on those specific points.

Adding constraints to your prompt (e.g., word count, specific keywords to include/exclude, format requirements) can often lead to more focused and useful outputs from the LLM.

Similar to text, image generation benefits from iteration. Start with a basic prompt, then refine it by adding details, styles (e.g., 'photorealistic', 'impressionist'), or camera angles.

If you need an LLM to explain a complex topic simply, ask it to use an analogy. For example, 'Explain quantum entanglement using an analogy involving a pair of gloves.'

For intricate tasks, consider a structured prompt with sections like: ROLE, CONTEXT, TASK, OUTPUT_FORMAT, EXAMPLES. This organization helps the LLM understand requirements better.

Ask the LLM to critique its own previous answer and then improve it. For example: 'Here is your previous response: [response]. Please identify any flaws and provide an improved version.'

To reduce hallucinations, explicitly instruct the LLM to say 'I don't know' or a similar phrase if it cannot answer a question confidently or accurately based on the provided context.

For mathematical or logical reasoning problems, adding the phrase 'Let's think step by step' before the LLM generates its solution significantly improves accuracy.

When using Claude, make use of its XML tags for better structure in your prompts.

When processing long documents, try to place key instructions or questions at the beginning or end of the input text. Models sometimes pay more attention to the start/end of context.

Start your prompt with a clear instruction like 'Translate the following text to French:' before providing the text itself. This primes the model for the task.

Treat your prompts as code. Use version control (like Git) to track changes, iterate, and collaborate on prompt engineering.

Incorporate keywords that suggest the desired style or tone, e.g., 'formal', 'casual', 'humorous', 'academic', 'empathetic'.

Understand the context window limit of the model you are using. Information outside this window will be ignored. For long interactions, summarization or RAG is key.

If a complex prompt isn't working, simplify it. Remove parts one by one to identify which section is causing the issue.

To generate more detailed and nuanced content, first ask for a brief outline, then ask the LLM to expand on each point, and then ask it to add specific examples or data. This is a form of 'Chain of Density'.

Review your prompts for ambiguous words or phrases that could be interpreted in multiple ways. Strive for explicitness.

Use stop sequences to tell the model when to stop generating text. This is useful for preventing run-on sentences or irrelevant content after the desired output.

For complex tasks involving multiple pieces of information, provide the input in a structured format (e.g., using JSON within the prompt, or clear headings) to help the LLM parse it correctly.

In a production environment, A/B test different prompt variations to empirically determine which ones yield the best results for your key metrics.

Ask the LLM to review its own previous output for errors or areas of improvement. 'Review your previous response. Are there any inaccuracies or ways to make it clearer?'

If your prompt uses domain-specific jargon or acronyms the LLM might not know, provide a small glossary or definitions within the prompt.

For complex tasks, chain multiple prompts together. The output of one LLM call becomes the input (or part of the input) for the next. This allows for sophisticated workflows.

The quality of your LLM's output is highly dependent on the quality of your input prompt. Clear, well-structured, and relevant prompts lead to better results.